1

$ cryptogen --help

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

OrdererOrgs: # 排序节点组织的信息
	-  Name: Orderer # 组织名
	   Domain: example.com # 根域名
	   Specs: # 几个orderer节点下面写几个子域名
	   	- Hostname: orderer # orderer.example.com
	   	- Hostname: order2 # order2.example.com

PeerOrgs: # peer节点组织的信息
	- Name: OrgGo # 组织名
	  Domain: orggo.example.com # 根域名
	  EnableNodeOUs: true # 启用cryptogen
	  Template: # 模板,根据默认规则生成2个peer存储数据的节点
	  	Count: 2 # 1. peer0.org1.example.com 2. peer1.org1.example.com
	  Users: # 创建的普通用户的个数
	  	Count: 3

	- Name: OrgCpp
	  Domain: orgcpp.example.com
	  EnableNodeOUs: true
	  Template:
	  	Count: 2
	  Users:
	  	Count: 3

1

$ cryptogen generate --config=yaml配置文件名

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

$ configtxgen --help
	# 输出创始块区块文件的路径和名字
	`-outputBlock string`
	# 指定创建的channel的名字,如果没指定系统会提供一个默认的名字.
	`-channelID string`
	# 表示输出通道文件路径和名字
	`-outputCreateChannelTx string`
	# 指定配置文件中的节点
	`-profile string`
	# 更新channel的配置信息
	`-outputAnchorPeersUpdate string`
	# 指定所属的组织名称
	`-asOrg string`
	# 要想执行这个命令,需要一个配置文件 configtx.yaml

 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
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75

# configtx.yaml
Organization: # 固定的不能改
	- &OrderOrg # 排序节点组织,自己起个名字
		Name: OrdererOrg # 排序节点的组织名
		ID: OrdererMSP # 排序节点组织的ID
		MSPDir: crypto-config/ordererOrganizations/example.com/msp
		
	- &Org1 # 第一个组织,自己起个名字
		Name: Org1MSP # 排序节点的组织名
		ID: Org1MSP # 排序节点组织的ID
		MSPDir: crypto-config/peerOrganizations/org1.example.com/msp
		AnchorPeers: # 锚节点
			- Host: peer0.org1.example.com # 指定一个peer节点的域名
			- Port: 7051  # 端口不要改
			
	- &Org2
		Name: Org2MSP
		ID: Org2MSP
		MSPDir: crypto-config/peerOrganizations/org2.example.com/msp
		AnchorPeers:
			- Host: peer0.org2.example.com
			- Port: 7051 
			
Capabilities: # 能力
	Global: &ChannelCapabilities
		V1_1: true
	Orderer: &ChannelCapabilities
		V1_1: true
	Application: &ApplicationCapabilities
		V1_2: true
		
Application: &ApplicationDefaults # 默认不用改
	Organization: 
Orderer: &OrderDefaults
	# Available types are "solo" and "kafka"
	# 共识机制 == 排序算法
	OrdererType: solo
	Addresses: # orderer节点的地址
		- orderer.example.com:7050 # 要看上一个yaml文件配置的orderer的域名 端口不要改
	
	# BatchTimeout,BatchSize,AbsoluteMaxBytes只要一个满足,区块就会产生
	BatchTimeout: 2s # 经过这么长时间,会产生一个区块
	BatchSize:
		MaxMessageCount: 10 # 交易的最大数量达到这个值,会产生一个区块,建议100左右
		AbsoluteMaxBytes: 99MB # 数据量达到这个值,会产生一个区块,32M/64M
		PreferredMaxBytes: 512KB
	Kafka:
		Brokers:
			- 127.0.0.1:9902
	Organization:
	
Profiles: # 不能改
	TwoOrgsOrdererGenessis: # 区块名字,可以改
		Capabilities:
			<<: *ChannelCapabilities
		Orderer:
			<<: *OrdererDefaults
			Organizations:
				- *OrdererOrg
			Capabilities:
				<<: *OrdererCapabilities
		Consortiums: # 联盟
			SampleConsortium: # 可以改
				Organizations:
					- *OrgGo
					- *OrgCpp
     TwoOrgsChannel: # 通道名字,可以改
         Consortium: SampleConsortium # 对应63行
         Application:
             <<: *ApplicationDefaults
             Organizations:
                 - *OrgGo
                 - *OrgCpp
             Capabilities:
                 <<: *ApplicationCapabilities

1

$ configtxgen -profile 第53行的区块名字 -outputBlock ./genesis.block

1
2

$ configtxgen -profile 第67行的通道名字 -outputCreateChannelTx channel.tx -channelID ichannel
# 若未指定channelID，则默认是mychannel

1
2
3
4

 # 组织的锚节点文件
configtxgen -profile 第67行的通道名字 -outputAnchorPeersUpdate CppMSPanchors.tx -channelID ichannel -asOrg OrgCppMSP
# go组织锚节点文件
configtxgen -profile 第67行的通道名字 -outputAnchorPeersUpdate GoMSPanchors.tx -channelID ichannel -asOrg OrgGoMSP

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

# 客户端docker容器启动之后, go的工作目录
- GOPATH=/opt/gopath    # 不需要修改
# docker容器启动之后, 对应的守护进程的本地套接字, 不需要修改
- CORE_VM_ENDPOINT=unix:///host/var/run/docker.sock
- CORE_LOGGING_LEVEL=INFO    # 日志级别
- CORE_PEER_ID=cli            # 当前客户端节点的ID, 自己指定
- CORE_PEER_ADDRESS=peer0.org1.example.com:7051 # 客户端连接的peer节点
- CORE_PEER_LOCALMSPID=     # 组织ID
- CORE_PEER_TLS_ENABLED=true    # 通信是否使用tls加密
- CORE_PEER_TLS_CERT_FILE=        # 证书文件
 /opt/gopath/src/github.com/hyperledger/fabric/peer/crypto/peerOrganizations/org1.example.com/peers/peer0.org1.example.com/tls/server.crt
- CORE_PEER_TLS_KEY_FILE=        # 私钥文件
 /opt/gopath/src/github.com/hyperledger/fabric/peer/crypto/peerOrganizations/org1.example.com/peers/peer0.org1.example.com/tls/server.key
-CORE_PEER_TLS_ROOTCERT_FILE=    # 根证书文件
 /opt/gopath/src/github.com/hyperledger/fabric/peer/crypto/peerOrganizations/org1.example.com/peers/peer0.org1.example.com/tls/ca.crt
# 指定当前客户端的身份
- CORE_PEER_MSPCONFIGPATH=      /opt/gopath/src/github.com/hyperledger/fabric/peer/crypto/peerOrganizations/org1.example.com/users/Admin@org1.example.com/msp

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

- ORDERER_GENERAL_LOGLEVEL=INFO    # 日志级别
- ORDERER_GENERAL_LISTENADDRESS=0.0.0.0    # orderer节点监听的地址
- ORDERER_GENERAL_GENESISMETHOD=file    # 创始块的来源, 指定file来源就是文件中
# 创始块对应的文件, 这个不需要改
- ORDERER_GENERAL_GENESISFILE=/var/hyperledger/orderer/orderer.genesis.block
- ORDERER_GENERAL_LOCALMSPID=OrdererMSP    # orderer节点所属的组的ID
- ORDERER_GENERAL_LOCALMSPDIR=/var/hyperledger/orderer/msp    # 当前节点的msp账号路径
# enabled TLS
- ORDERER_GENERAL_TLS_ENABLED=true    # 是否使用tls加密
- ORDERER_GENERAL_TLS_PRIVATEKEY=/var/hyperledger/orderer/tls/server.key    # 私钥
- ORDERER_GENERAL_TLS_CERTIFICATE=/var/hyperledger/orderer/tls/server.crt    # 证书
- ORDERER_GENERAL_TLS_ROOTCAS=[/var/hyperledger/orderer/tls/ca.crt]            # 根证书

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

- CORE_PEER_ID=peer0.orggo.test.com    # 当前peer节点的名字, 自己起
# 当前peer节点的地址信息
- CORE_PEER_ADDRESS=peer0.orggo.test.com:7051
# 启动的时候, 指定连接谁, 一般写自己就行
- CORE_PEER_GOSSIP_BOOTSTRAP=peer0.orggo.test.com:7051
# 为了被其他节点感知到, 如果不设置别的节点不知有该节点的存在
- CORE_PEER_GOSSIP_EXTERNALENDPOINT=peer0.orggo.test.com:7051
- CORE_PEER_LOCALMSPID=OrgGoMSP
# docker的本地套接字地址, 不需要改
- CORE_VM_ENDPOINT=unix:///host/var/run/docker.sock
# 当前节点属于哪个网络
- CORE_VM_DOCKER_HOSTCONFIG_NETWORKMODE=network_default
- CORE_LOGGING_LEVEL=INFO
- CORE_PEER_TLS_ENABLED=true
- CORE_PEER_GOSSIP_USELEADERELECTION=true    # 自动选举leader节点
- CORE_PEER_GOSSIP_ORGLEADER=false            # 当前不是leader
- CORE_PEER_PROFILE_ENABLED=true    # 在peer节点中有一个profile服务
- CORE_PEER_TLS_CERT_FILE=/etc/hyperledger/fabric/tls/server.crt
- CORE_PEER_TLS_KEY_FILE=/etc/hyperledger/fabric/tls/server.key
- CORE_PEER_TLS_ROOTCERT_FILE=/etc/hyperledger/fabric/tls/ca.crt

1
2

# 在docker-compose.yaml 文件目录下执行下边命令
docker-compose up -d

1

docker-compose ps

1

docker exec -it cli /bin/bash

1
2
3
4
5
6
7
8
9

$ peer channel create [flags], 常用参数为:
	`-o, --orderer: orderer节点的地址
	`-c, --channelID: 要创建的通道的ID, 必须小写, 在250个字符以内
	`-f, --file: 由configtxgen 生成的通道文件, 用于提交给orderer
	-t, --timeout: 创建通道的超时时长, 默认为5s
	`- -tls: 通信时是否使用tls加密
	`- -cafile: 当前orderer节点pem格式的tls证书文件, 要使用绝对路径.
# example
peer channel create -o orderer节点地址:端口 -c 通道名 -f 通道文件 --tls true --cafile orderer节点pem格式的证书文件

1
2
3

$ peer channel join[flags], 常用参数为:
    `-b, --blockpath: 通过 peer channel create 命令生成的通道文件 
$ peer channel join -b 生成的通道block文件

1
2
3
4
5
6
7
8
9

$ peer channel update -o ubuntu.itcast.com:7050 -c $CHANNEL_NAME -f ./channelartifacts/${CORE_PEER_LOCALMSPID}anchors.tx --tls $CORE_PEER_TLS_ENABLED --cafile
$ORDERER_CA
# 参数说明:
- ubuntu.itcast.com: 连接的orderer的地址，hostname:port
- ${CORE_PEER_LOCALMSPID}anchors.tx: 组织的锚节点文件, 是通过configtxgen指令生成的
- $CORE_PEER_TLS_ENABLED: 和orderer通信时是否启用tls
- $ORDERER_CA: 使用tls时，所使用的orderer的证书
# example
$ peer channel update -o orderer节点地址:端口 -c 通道名 -f 锚节点更新文件 --tls true --cafile orderer节点pem格式的证书文件

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

$ peer chaincode install [flags], 常用参数为:
    -c, --ctor: JSON格式的构造参数, 默认是"{}"
    `-l, --lang: 编写chaincode的编程语言, 默认值是 golang
    `-n, --name: chaincode的名字
    `-p, --path: chaincode源代码的目录, 从 $GOPATH/src 路径后开始写
    `-v, --version: 当前操作的chaincode的版本, 适用这些命令install/instantiate/upgrade
# example
$ peer chaincode install -n 链码的名字 -v 链码的版本 -l 链码的语言 -p 链码的位置
    - 链码名字自己起
    - 链码的版本, 自己根据实际情况指定

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

$ peer chaincode instantiate [flags], 常用参数为:
    `-C，--channelID：当前命令运行的通道，默认值是“testchainid"。
    `-c, --ctor：JSON格式的构造参数，默认值是“{}"
    `-l，--lang：编写Chaincode的编程语言，默认值是golang
    `-n，--name：Chaincode的名字。
    `-P，--policy：当前Chaincode的背书策略。
    `-v，--version：当前操作的Chaincode的版本，适用于install/instantiate/upgrade等命令
    `--tls: 通信时是否使用tls加密
    `--cafile: 当前orderer节点pem格式的tls证书文件, 要使用绝对路径.
# example
$ peer chaincode instantiate -o orderer节点地址:端口 --tls true --cafile orderer节点pem格式的证书文件 -C 通道名称 -n 链码名称 -l 链码语言 -v 链码版本 -c 链码Init函数调用 -P 背书策略

1
2

// 一个chaincode通常是一个Golang源代码文件, 在这份源代码中, 包名必须是main
package main

1
2
3
4
5
6
7
8
9

// ChainCode需要引入Fabric提供的一些系统包, 这些系统提供了ChainCode和Fabric进行通信的接口
// 必须要引入包的如下:
import ( 
    "github.com/hyperledger/fabric/core/chaincode/shim"
    pb "github.com/hyperledger/fabric/protos/peer"
)
/*
在引入包中 "github.com/hyperledger/fabric/core/chaincode/shim" 是Fabric提供的上下文环境,包含了Fabric和ChainCode交互的接口。在ChainCode中，执行赋值、查询等功能都需要通过shim。
*/

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

/*
每个ChainCode都需要定义一个结构体，结构体的名字可以是任意符合Golang命名规范的字符串。
*/
// 自定义结构体名为: chainCodeStudy
type TestStudy struct {
    //空着
}
/*
Chaincode结构体是ChainCode的主体结构。ChainCode结构体需要实现Fabric提供的接口：
"github.com/hyperledger/fabric/protos/peer"，其中必须实现下面两个方法：
*/
// 系统初始化
func (t *TestStudy) Init(stub shim.ChaincodeStubInterface) pb.Response {};
// 数据写入
func (t *TestStudy) Invoke(stub shim.ChaincodeStubInterface) pb.Response{}；

1

$ peer chaincode instantiate -o orderer.test.com:7050 -C mychanne -n mytestcc -v 1.0 -c '{"Args": ["init"，"a"， "100"，"b"，"200"]}'

1
2
3
4
5

func (t *TestStudy) Init(stub shim.ChaincodeStubInterface) pb.Response {
    // 获取客户端传入的参数, args是一个字符串, 存储传入的字符串参数
    _, args := stub.GetFunctionAndParameters()
    return shim.Success([]byte("sucess init!!!"))
};

1
2

$ peer chaincode invoke -o 192.168.1.100:7050 -C mychanne -n mytestcc -c '{"Args":
["invoke"，"a"，"b"，"10"]}'

1
2
3
4
5
6

func (t *TestStudy) Invoke(stub shim.ChaincodeStubInterface) pb.Response {
    // 进行交易操作的源代码, 调用ChaincodeStubInterface接口中的方法
    // stub.xxx()
    // stub.yyy()
    return shim.Success([]byte("sucess invoke!!!"))
};

1
2
3
4
5
6
7
8
9

/*
Sucess 方法负责将正确的消息返回给调用ChainCode的客户端, Sucess方法的定义和调用如下:
*/
// 方法定义
func Success(payload []byte) pb.Response;
// 示例代码
func (t *TestStudy) Invoke(stub shim.ChaincodeStubInterface) pb.Response {
	return shim.Success([]byte("sucess invoke!!!"))
};

1
2
3
4
5
6
7

// Error方法负责将错误信息返回给调用ChainCode的客户端, Error方法的定义和调用如下
// 方法定义
func Error(msg string) pb.Response;
// 示例代码
func (t *TestStudy) Invoke(stub shim.ChaincodeStubInterface) pb.Response {
	return shim.Error("operation fail!!!")
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

// LogLevel方法负责修改ChainCode中运行日志的级别, LogLevel方法的定义和调用如下
// 将日志级别描述字符串转为 LoggingLevel 类型
func LogLevel(levelString string) (LoggingLevel, error);
    - levelString可用参数:
        - CRITICAL, 级别最高, 写日志最少
        - ERROR
        - WARNING
        - NOTICE
        - INFO
        - DEBUG, 级别最低, 写日志最多
// 设置日志级别
func SetLoggingLevel(level LoggingLevel);

// 示例代码
func (t *TestStudy) Invoke(stub shim.ChaincodeStubInterface) pb.Response {
    loglevel, _ := shim.LogLevel("debug")
    shim.setLoggingLevel(loglevel)
    return shim.Success([]byte("operation fail!!!"))
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

// 赋值接收调用chaincode的客户端传递过来的参数
func GetFunctionAndParameters() (function string, params []string);
// 示例代码
func (t *TestStudy) Invoke(stub shim.ChaincodeStubInterface) pb.Response {
    // 获取客户端传入的参数, args是一个字符串, 存储传入的字符串参数
    _, args := stub.GetFunctionAndParameters()
    var a_param = args[0]
    var b_param = args[1]
    var c_param = args[2]
    return shim.Success([]byte("sucess init!!!"))
};

1
2
3
4
5
6
7
8

// 把客户端传递过来的数据保存到Fabric中, 数据格式为键值对
func PutState(key string, value []byte) error;
// 示例代码
func (t *TestStudy) Invoke(stub shim.ChaincodeStubInterface) pb.Response {
    // 数据写入
    stub.PutState("user1", []byte("putvalue"))
    return shim.Success([]byte("sucess invoke user1"))
};

1
2
3
4
5
6
7
8

// 从Fabric中取出数据, 然后把这些数据交给chaincode处理.
func GetState(key string) ([]byte, error);
// 示例代码
func (t *TestStudy) Invoke(stub shim.ChaincodeStubInterface) pb.Response {
    // 读数据
    keyvalue, err := stub.GetState("user1")
    return shim.Success(keyvalue)
};

 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

// 根据key的访问查询相关数据
func GetStateByRange(startKey,endKey string)(StateQueryIteratorInterface,error);
// 示例代码
func (t *TestStudy) Invoke(stub shim.ChaincodeStubInterface) pb.Response {
    startKey := "startkey"
    endKey := "endkey"
    // 根据范围查询, 得到StateQueryIteratorInterface迭代器接口
    keysIter, err := stub.getStateByRange(startKey, endKey)
    // 最后关闭迭代器接口
    defer keysIter.Close()
    var keys []string
    for keysIter.HasNext() { // 如果有下一个节点
        // 得到下一个键值对
        response, iterErr := keysIter.Next()
        if iterErr != nil {
        	return shim.Error(fmt.Sprintf("find an error %s", iterErr))
        }
        keys = append(keys, response.Key) // 存储键值到数组中
    }
    // 遍历keys数组
    for key, value := range keys {
    	fmt.Printf("key %d contains %s\n", key, value)
    }
    // 编码keys数组成json格式
    jsonKeys, err := json.Marshal(keys)
    if err := nil {
    	return shim.Error(fmt.Sprintf("data Marshal json error: %s", err))
    }
    // 将编码之后的json字符串传递给客户端
    return shim.Success(jsonKeys)
};

 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

// 查询某个键的历史记录
func GetHistoryForKey(key string) (HistoryQueryIteratorInterface, error);
// 示例代码
func (t *TestStudy) Invoke(stub shim.ChaincodeStubInterface) pb.Response {
    keysIter, err := stub.GetHistoryForKey("user1") // user1是一个假设的键值
    if err := nil {
		return shim.Error(fmt.Sprintf("GetHistoryForKey error: %s", err))
}
    defer keysIter.Close()
    var keys []string
    for keysIter.HasNext() { // 遍历集合,如果有下一个节点
        // 得到下一个键值对
        response, iterErr := keysIter.Next()
        if iterErr != nil {
        return shim.Error(fmt.Sprintf("find an error %s", iterErr))
        }
        // 交易编号
        txid := response.TxId
        // 交易的值
        txvalue := response.Value
        // 当前交易的状态
        txStatus := response.IsDelete
        // 交易发生的时间戳
        txtimestamp := response.Timestamp
        // 计算从1970.1.1到时间戳的秒数
        tm := time.Unix(txtimestamp.Seconds, 0)
        // 根据指定的格式将日期格式化
        datestr := tm.Format("2018-11-11 11:11:11 AM")
        fmt.Printf("info - txid:%s, value:%s, isDel:%t, dateTime:%s\n", txid,
		string(txvalue), txStatus, datestr)
		keys = append(keys, txid)
	}
    // 将数组中历史信息的key编码为json格式
    jsonKeys, err := json.Marshal(keys)
    if err := nil {
		return shim.Error(fmt.Sprintf("data Marshal json error: %s", err))
}
    // 将编码之后的json字符串传递给客户端
    return shim.Success(jsonKeys)
}	

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

// 删除一个key
func DelState(key string) error;
// 示例代码
func (t *TestStudy) Invoke(stub shim.ChaincodeStubInterface) pb.Response {
    err := stub.DelState("delKey")
    if err != nil {
    	return shim.Error("delete key error !!!")
    }
    return shim.Success("delete key Success !!!")
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

// 给定一组属性，将这些属性组合起来构造一个复合键
func CreateCompositeKey(objectType string, attributes []string) (string,
error);
// 示例代码
func (t *TestStudy) Invoke(stub shim.ChaincodeStubInterface) pb.Response {
    parms := []string("go1", "go2", "go3", "go4", "go5", "go6")
    ckey, _ := stub.CreateCompositeKey("testkey", parms)
    // 复合键存储到账本中
    err := stub.putState(ckey, []byte("hello, go"))
    if err != nil {
    	fmt.Println("find errors %s", err)
    }
    // print value: testkeygo1go2go3go4go5go6
    fmt.Println(ckey)
    return shim.Success([]byte(ckey))
}

 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

// 根据局部的复合键返回所有的匹配的键值
func GetStateByPartialCompositeKey(objectType string, keys []string)
(StateQueryIteratorInterface, error);
// 给定一个复合键，将其拆分为复合键所有的属性
func SplitCompositeKey(compositeKey string) (string, []string, error)
// 示例代码
func (t *TestStudy) Invoke(stub shim.ChaincodeStubInterface) pb.Response {
    searchparm := []string{"go1"}
    rs, err := stub.GetStateByPartialCompositeKey("testkey", searchparm)
    if err != nil {
        error_str := fmt.Sprintf("find error %s", err)
        return shim.Error(error_str)
    }
    defer rs.Close()
    var tlist []string
    for rs.HasNext() {
		responseRange, err := rs.Next()
        if err != nil {
            error_str := fmt.Sprintf("find error %s", err)
            fmt.Println(error_str)
            return shim.Error(error_str)
        }
        value1,compositeKeyParts,_ := stub.SplitCompositeKey(responseRange,
        key)
        value2 := compositeKeyParts[0]
        value3 := compositeKeyParts[1]
        // print: find value v1:testkey, v2:go1, v3go2
        fmt.Printf("find value v1:%s, v2:%s, V3:%s\n", value1, value2,
        value3)
    }
    return shim.Success("success")
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

// 获取当前客户端发送的交易时间戳
func GetTxTimestamp() (*timestamp.Timestamp, error);
// 示例代码
func (t *TestStudy) Invoke(stub shim.ChaincodeStubInterface) pb.Response {
	txtime, err := stub.GetTxTimestamp()
    if err != nil {
        fmt.printf("Error getting transaction timestamp: %s", error)
        return shim.Error(fmt.Sprintf("get transaction timestamp error: %s",
    error))
    }
    tm := time.Unix(txtime.Second, 0)
    return shim.Success([]byte(fmt.Sprint("time is: %s", tm.Format("2018-11-11
    23:23:32"))))
}

 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

// 调用另一个链码中的Invoke方法
func InvokeChaincode(chaincodeName string,args [][]byte,channel string)
pb.Response
// 示例代码
func (t *TestStudy) Invoke(stub shim.ChaincodeStubInterface) pb.Response {
    // 设置参数, a向b转转11
    trans:=[][]byte{[]byte("invoke"),[]byte("a"),[]byte("b"),[]byte("11")}
    // 调用chaincode
    response := stub.InvokeChaincode("mycc", trans, "mychannel")
	// 判断是否操作成功了
    // 课查询:
    https://godoc.org/github.com/hyperledger/fabric/protos/peer#Response
    if response.Status != shim.OK {
        errStr := fmt.Sprintf("Invoke failed, error: %s", response.Payload)
        return shim.Error(errStr)
    }
    return shim.Success([]byte("转账成功..."))
}
// ==================================================
// 获取客户端发送的交易编号
func GetTxID() string
// 示例代码
func (t *TestStudy) Invoke(stub shim.ChaincodeStubInterface) pb.Response {
    txid := stub.GetTxID()
    return shim.Success([]byte(txid))
}

1
2
3
4

$ peer chaincode instantiate -o oraderer.test.com:7050 -C mychannel -n mycc —v 1.0 -c
'{"Args":["init", "a", "100", "b", "200"]}' -P "AND ('Org1MSP.member', 'Org2MSP.member')"
# 上述命令是对Chaincode进行实例化的操作，我们提取-P后面的参数：
"AND ('Org1MSP.member', 'Org2MSP.member')"

1
2

# 按照该背书规则进行交易, 必须通过组织Org1MSP，Org2MSP，Org3MSP中的用户共同验证交易才能生效
"AND ('Org1MSP.member', 'Org2MSP.member', 'Org3MSP.member')"

1
2

# 按照该背书规则进行交易,只需要通过组织 Org1MSP 或 Org2MSP 或 Org3MSP 中的任何一个成员验证，即可生效
"OR ('Org1MSP.member', 'Org2MSP.member', 'Org3MSP.member')"

1
2
3
4

# 按照该背书规则进行交易,有两种办法让交易生效
# 1. 组织Org1MSP中的某个成员对交易进行验证。
# 2. 组织Org2MSP和组织Org3MSP中的成员共同就交易进行验证。
"OR ('Org1MSP.member', AND（'Org2MSP.member', 'Org3MSP.member'))"

1
2

PutState(key string, value []byte) error;
DelState(key string) error;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

//chaincode/go/test1/test.go  -》 对应链码名testcc
package main
import {}
type Test struct{}
func (t *Test)Init();
func (t *Test)Invoke();	//业务逻辑1
func main(){}

//chaincode/go/test2/test1.go -》 对应链码名testcc1
package main
import {}
type Test struct{}
func (t *Test)Init();
func (t *Test)Invoke();	//业务逻辑2
func main(){}

  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
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183

package main

//WARNING - this chaincode's ID is hard-coded in chaincode_example04 to illustrate one way of
//calling chaincode from a chaincode. If this example is modified, chaincode_example04.go has
//to be modified as well with the new ID of chaincode_example02.
//chaincode_example05 show's how chaincode ID can be passed in as a parameter instead of
//hard-coding.

import (
        "fmt"
        "strconv"

        "github.com/hyperledger/fabric/core/chaincode/shim"
        pb "github.com/hyperledger/fabric/protos/peer"
)

// SimpleChaincode example simple Chaincode implementation
type SimpleChaincode struct {
}

func (t *SimpleChaincode) Init(stub shim.ChaincodeStubInterface) pb.Response {
        fmt.Println("ex02 Init")
        _, args := stub.GetFunctionAndParameters()   // 获取调用的函数参数， 返回值_就是Init，args是后接的参数
        var A, B string    // Entities
        var Aval, Bval int // Asset holdings
        var err error

        if len(args) != 4 {			//判断参数个数
                return shim.Error("Incorrect number of arguments. Expecting 4")
        }

        // Initialize the chaincode
        A = args[0]
        Aval, err = strconv.Atoi(args[1])
        if err != nil {
                return shim.Error("Expecting integer value for asset holding")
        }
        B = args[2]
        Bval, err = strconv.Atoi(args[3])
        if err != nil {
                return shim.Error("Expecting integer value for asset holding")
        }
        fmt.Printf("Aval = %d, Bval = %d\n", Aval, Bval)

        // Write the state to the ledger  把数据写入账本中
        err = stub.PutState(A, []byte(strconv.Itoa(Aval)))  
        if err != nil {
                return shim.Error(err.Error())
        }

        err = stub.PutState(B, []byte(strconv.Itoa(Bval)))
        if err != nil {
                return shim.Error(err.Error())
        }

        return shim.Success(nil)
}

func (t *SimpleChaincode) Invoke(stub shim.ChaincodeStubInterface) pb.Response {  //交易函数
        fmt.Println("ex02 Invoke")
        function, args := stub.GetFunctionAndParameters()  //获取参数，function是第一个参数代表保存的函数名，这里是invoke
    	//“路由设置”
        if function == "invoke" {
                // Make payment of X units from A to B
                return t.invoke(stub, args)
        } else if function == "delete" {
                // Deletes an entity from its state
                return t.delete(stub, args)
        } else if function == "query" {
                // the old "Query" is now implemtned in invoke
                return t.query(stub, args)
        }

        return shim.Error("Invalid invoke function name. Expecting \"invoke\" \"delete\" \"query\"")
}
// Transaction makes payment of X units from A to B
func (t *SimpleChaincode) invoke(stub shim.ChaincodeStubInterface, args []string) pb.Response {
        var A, B string    // Entities
        var Aval, Bval int // Asset holdings
        var X int          // Transaction value
        var err error

        if len(args) != 3 {
                return shim.Error("Incorrect number of arguments. Expecting 3")
        }

        A = args[0]
        B = args[1]

        // Get the state from the ledger
        // TODO: will be nice to have a GetAllState call to ledger
        Avalbytes, err := stub.GetState(A)  	//获取A的资产
        if err != nil {
                return shim.Error("Failed to get state")
        }
        if Avalbytes == nil {
                return shim.Error("Entity not found")
        }
        Aval, _ = strconv.Atoi(string(Avalbytes))

        Bvalbytes, err := stub.GetState(B) 		//获取B的资产
        if err != nil {
                return shim.Error("Failed to get state")
        }
        if Bvalbytes == nil {
                return shim.Error("Entity not found")
        }
        Bval, _ = strconv.Atoi(string(Bvalbytes))

        // Perform the execution
        X, err = strconv.Atoi(args[2])  	//获取转账金额
        if err != nil {
                return shim.Error("Invalid transaction amount, expecting a integer value")
        }
        Aval = Aval - X  		// 转账
        Bval = Bval + X	
        fmt.Printf("Aval = %d, Bval = %d\n", Aval, Bval)

        // Write the state back to the ledger
        err = stub.PutState(A, []byte(strconv.Itoa(Aval)))		//重新写入
        if err != nil {
                return shim.Error(err.Error())
        }

        err = stub.PutState(B, []byte(strconv.Itoa(Bval)))		//重新写入
        if err != nil {
                return shim.Error(err.Error())
        }

        return shim.Success(nil)
}

// Deletes an entity from state
func (t *SimpleChaincode) delete(stub shim.ChaincodeStubInterface, args []string) pb.Response {
        if len(args) != 1 {
                return shim.Error("Incorrect number of arguments. Expecting 1")
        }

        A := args[0]

        // Delete the key from the state in ledger
        err := stub.DelState(A)			//删除账本中的key，假删除，这个操作是被记录的
        if err != nil {
                return shim.Error("Failed to delete state")
        }

        return shim.Success(nil)
}

// query callback representing the query of a chaincode
func (t *SimpleChaincode) query(stub shim.ChaincodeStubInterface, args []string) pb.Response {		//查询函数
        var A string // Entities
        var err error

        if len(args) != 1 {
                return shim.Error("Incorrect number of arguments. Expecting name of the person to query")
        }

        A = args[0]

        // Get the state from the ledger
        Avalbytes, err := stub.GetState(A)	//取出值
        if err != nil {
                jsonResp := "{\"Error\":\"Failed to get state for " + A + "\"}"
                return shim.Error(jsonResp)
        }

        if Avalbytes == nil {
                jsonResp := "{\"Error\":\"Nil amount for " + A + "\"}"
                return shim.Error(jsonResp)
        }

        jsonResp := "{\"Name\":\"" + A + "\",\"Amount\":\"" + string(Avalbytes) + "\"}"		//拼接成字符串给客户端
        fmt.Printf("Query Response:%s\n", jsonResp)
        return shim.Success(Avalbytes)
}

func main() {
        err := shim.Start(new(SimpleChaincode))  //写法固定  SimpleChaincode就是定义的空结构体
        if err != nil {
                fmt.Printf("Error starting Simple chaincode: %s", err)
        }
}

1
2
3
4

func (t  *自定义结构体) 
functionName (stub shim.ChaincodeStubInterface, args []string) pb.Response {
	xxxxx
}

1
2
3

# 环境变量账号：->该路径为宿主机上的路径,非docker启动的orderer节点内部挂载路径
ORDERER_GENERAL_LOCALMSPDIR=
# 账号目录信息

1
2
3

# 环境变量账号：->该路径为宿主机上的路径,非docker启动的orderer节点内部挂载路径
CORE_PEER_MSPCONFIGPATH=
# 账号目录信息

1
2
3
4

# 环境变量账号：->该路径为宿主机上的路径,非docker启动的orderer节点内部挂载路径

CORE_PEER_MSPCONFIGPATH=
# 账号目录信息

1
2
3
4
5
6

# Orderer启动路径
crypto-config/ordererOrganizations/itcast.com/orderers/orderer.itcast.com/msp
# Peer启动的账号路径
crypto-config/peerOrganizations/orggo.itcast.com/peers/peere0.orggo.itcast.com/msp
# 创建channel的账号路径
crypto-config/peerOrganizations/orggo.itcast.com/users/Admin@orggo.itcast.com/msp

1
2
3
4

# 1. 编写组织信息的配置文件, 该文件中声明每个组织有多少个节点, 多少用户
# 在这个配置文件中声明了每个节点访问的地址(域名)
# 一般命名为crypto-config.yaml
$ cryptogen generate --config=xxx.yaml

1

$ configtxgen -profile [从configtx.yaml->profiles->下属字段名] -outputxxxx

1
2

ORDERER_GENERAL_GENESISMETHOD=file
ORDERER_GENERAL_GENESISFILE=/var/hyperledger/orderer/orderer.genesis.block

1

# docker-compose.yaml

1

$ docker-compose up -d

1

$ docker-compose ps

1
2
3
4

# docker-compose.yaml
 - 两个服务器
 	- peer
 	- cli

1

$ docker-compose up -d

1

$ docker-compose ps

1

$ docker exec -it cli bash