/
main.go
238 lines (227 loc) · 6.71 KB
/
main.go
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
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
package main
import (
. "github.com/davidkhala/fabric-common-chaincode-golang"
"github.com/davidkhala/fabric-common-chaincode-golang/cid"
"github.com/davidkhala/fabric-common-chaincode-golang/ext"
. "github.com/davidkhala/goutils"
httputil "github.com/davidkhala/goutils/http"
"github.com/hyperledger/fabric-chaincode-go/shim"
"github.com/hyperledger/fabric-protos-go/msp"
"github.com/hyperledger/fabric-protos-go/peer"
logger "github.com/sirupsen/logrus"
)
const (
name = "diagnose"
collectionPrivate = "private"
)
type diagnoseChaincode struct {
CommonChaincode
}
func (t diagnoseChaincode) Init(stub shim.ChaincodeStubInterface) (response peer.Response) {
defer Deferred(DeferHandlerPeerResponse, &response)
t.Prepare(stub)
var fcn, params = stub.GetFunctionAndParameters()
logger.Info("Init ", fcn, params)
t.printTransient()
return shim.Success(nil)
}
func (t diagnoseChaincode) printTransient() {
var transientMap = t.GetTransient()
logger.Debug("==[start]transientMap")
for k, v := range transientMap {
logger.Debug(k, ":", string(v))
}
logger.Debug("==[end]transientMap")
}
type txData struct {
Time TimeLong
Value []byte
}
func (t diagnoseChaincode) Invoke(stub shim.ChaincodeStubInterface) (response peer.Response) {
defer Deferred(DeferHandlerPeerResponse, &response)
t.Prepare(stub)
fcn, params := stub.GetFunctionAndParameters()
var args = stub.GetArgs()
logger.Info("Invoke ", fcn, params)
var transient = t.GetTransient()
var responseBytes []byte
switch fcn {
case "panic":
PanicString("test panic")
case "richQuery":
var query = params[0]
logger.Info("Query string", query)
var queryIter = t.GetQueryResult(query)
var states = ParseStates(queryIter, nil)
responseBytes = ToJson(states)
case "worldStates":
var states = t.WorldStates("", nil)
responseBytes = ToJson(states)
case "whoami":
responseBytes = ToJson(cid.NewClientIdentity(stub))
case "peerMSPID":
responseBytes = []byte(GetMSPID())
case "get":
var key = params[0]
var tx txData
t.GetStateObj(key, &tx)
responseBytes = tx.Value
case "putImplicit":
var mspid = GetMSPID()
if len(params) == 1 {
mspid = params[0]
}
var collection = ImplicitCollection(mspid)
for k, v := range transient {
t.PutPrivateData(collection, k, v)
}
case "getImplicit":
var mspid = GetMSPID()
if len(params) == 1 {
mspid = params[0]
}
var collection = ImplicitCollection(mspid)
var privateKV = map[string]string{}
for k := range transient {
var valueBytes = t.GetPrivateData(collection, k)
privateKV[k] = string(valueBytes)
}
responseBytes = ToJson(privateKV)
case "putPrivate":
for k, v := range transient {
t.PutPrivateData(collectionPrivate, k, v)
}
case "getPrivate":
var privateKV = map[string]string{}
for k := range transient {
var valueBytes = t.GetPrivateData(collectionPrivate, k)
privateKV[k] = string(valueBytes)
}
responseBytes = ToJson(privateKV)
case "readWritePrivate":
for k, v := range transient {
t.GetPrivateData(collectionPrivate, k)
t.PutPrivateData(collectionPrivate, k, v)
}
case "putRaw":
// for leveldb hacker analyzer
var key = params[0]
var value = args[2]
t.PutState(key, value)
case "getRaw":
var key = params[0]
responseBytes = t.GetState(key)
case "history":
var key = params[0]
var iter = t.GetHistoryForKey(key)
var modifications = ParseHistory(iter, nil)
responseBytes = ToJson(modifications)
case "put":
var key = params[0]
var value = params[1]
var time TimeLong
t.PutStateObj(key, txData{
time.FromTimeStamp(t.GetTxTimestamp()),
[]byte(value),
})
case "deleteEndorsement":
var key = params[0]
t.SetStateValidationParameter(key, nil)
case "putEndorsement":
var key = params[0]
var MSPIDs = params[1:]
var policy = ext.NewKeyEndorsementPolicy(nil)
policy.AddOrgs(msp.MSPRole_MEMBER, MSPIDs...)
var policyBytes = policy.Policy()
logger.Info(policyBytes)
t.SetStateValidationParameter(key, policyBytes)
case "getEndorsement":
var key = params[0]
var policyBytes = t.GetStateValidationParameter(key)
logger.Info(policyBytes) // FIXME empty here
var policy = ext.NewKeyEndorsementPolicy(policyBytes)
var orgs = policy.ListOrgs()
responseBytes = ToJson(orgs)
case "delegate":
type crossChaincode struct {
ChaincodeName string
Fcn string
Args []string
Channel string
}
var paramInput crossChaincode
FromJson([]byte(params[0]), ¶mInput)
var args = ArgsBuilder(paramInput.Fcn)
for i, element := range paramInput.Args {
args.AppendArg(element)
logger.Debug("delegated Arg", i, element)
}
var pb = t.InvokeChaincode(paramInput.ChaincodeName, args.Get(), paramInput.Channel)
responseBytes = pb.Payload
case "listPage":
var startKey = params[0]
var endKey = params[1]
var pageSize = Atoi(params[2])
var bookMark = params[3]
var iter, metaData = t.GetStateByRangeWithPagination(startKey, endKey, pageSize, bookMark)
type Response struct {
States []StateKV
MetaData QueryResponseMetadata
}
responseBytes = ToJson(Response{ParseStates(iter, nil), metaData})
case "GetStateByRange":
var startKey = params[0]
var endKey = params[1]
var iter = t.GetStateByRange(startKey, endKey)
responseBytes = ToJson(ParseStates(iter, nil))
case "GetCompositeStateByRange":
var objectType = params[0]
var iter = t.GetStateByPartialCompositeKey(objectType, nil)
responseBytes = ToJson(ParseStates(iter, nil))
case "putBatch":
var batch map[string]string
FromJson([]byte(params[0]), &batch)
for k, v := range batch {
t.PutState(k, []byte(v))
}
case "chaincodeId":
responseBytes = []byte(t.GetChaincodeID())
case "getCertID":
var certID = cid.NewClientIdentity(stub).GetID()
responseBytes = []byte(certID)
case "createComposite":
var objectType = params[0]
var attr1 = params[1:]
var compositeKey = t.CreateCompositeKey(objectType, attr1)
responseBytes = []byte(compositeKey)
case "putComposite":
var objectType = params[0]
var attr1 = params[1:]
var transient = t.GetTransient()
var value = transient["value"]
var compositeKey = t.CreateCompositeKey(objectType, attr1)
t.PutState(compositeKey, value)
case "putCompositeBatch":
var objectType = params[0]
var batch = t.GetTransient()
for k, v := range batch {
var compositeKey = t.CreateCompositeKey(objectType, []string{k})
t.PutState(compositeKey, v)
}
case "setEvent":
var eventName = params[0]
var event = params[1]
t.SetEvent(eventName, []byte(event))
case "external":
resp := httputil.Get("http://www.google.com", nil)
responseBytes = []byte(resp.Status)
default:
panic("fcn not found:" + fcn)
}
return shim.Success(responseBytes)
}
func main() {
var cc = diagnoseChaincode{}
logger.Info("chaincode", name, "start")
ChaincodeStart(cc)
}