go - 自定义事务处理器未收到请求

Question

为什么我的交易处理器没有收到我通过其余 API 发布的请求？

我用 Golang 构建了一个客户端和事务处理器(TP)，这与 XO 示例没有太大区别。我已成功让 TP 在 Sawtooth 组件本地运行，并从单独的 cli 工具发送批处理列表。目前TP中的apply方法没有被命中，也没有收到我的任何交易。

编辑:为了尽可能简化和澄清我的问题，我放弃了原来的源代码，并构建了一个更简单的客户端，为 XO sdk 示例发送交易。*

当我运行我构建的工具时，其余 api 成功接收请求、处理并返回 202 响应，但似乎省略了批处理状态 URL 中的批处理 ID。检查日志，验证器似乎从未收到来自其余 api 的请求，如下面的日志所示。

sawtooth-rest-api-default | [2018-05-16 09:16:38.861 DEBUG    route_handlers] Sending CLIENT_BATCH_SUBMIT_REQUEST request to validator
sawtooth-rest-api-default | [2018-05-16 09:16:38.863 DEBUG    route_handlers] Received CLIENT_BATCH_SUBMIT_RESPONSE response from validator with status OK
sawtooth-rest-api-default | [2018-05-16 09:16:38.863 INFO     helpers] POST /batches HTTP/1.1: 202 status, 213 size, in 0.002275 s

下面是我将事务发送到本地实例的整个命令行工具。

package main

import (
    "bytes"
    "crypto/sha512"
    "encoding/base64"
    "encoding/hex"
    "flag"
    "fmt"
    "io/ioutil"
    "log"
    "math/rand"
    "net/http"
    "strings"
    "time"

    "github.com/hyperledger/sawtooth-sdk-go/protobuf/batch_pb2"
    "github.com/hyperledger/sawtooth-sdk-go/protobuf/transaction_pb2"
    "github.com/hyperledger/sawtooth-sdk-go/signing"
)

var restAPI string

func main() {
    var hostname, port string

    flag.StringVar(&hostname, "hostname", "localhost", "The hostname to host the application on (default: localhost).")
    flag.StringVar(&port, "port", "8080", "The port to listen on for connection (default: 8080)")
    flag.StringVar(&restAPI, "restAPI", "http://localhost:8008", "The address of the sawtooth REST API")

    flag.Parse()

    s := time.Now()
    ctx := signing.CreateContext("secp256k1")
    key := ctx.NewRandomPrivateKey()
    snr := signing.NewCryptoFactory(ctx).NewSigner(key)

    payload := "testing_new,create,"
    encoded := base64.StdEncoding.EncodeToString([]byte(payload))

    trn := BuildTransaction(
        "testing_new",
        encoded,
        "xo",
        "1.0",
        snr)

    trn.Payload = []byte(encoded)

    batchList := &batch_pb2.BatchList{
        Batches: []*batch_pb2.Batch{
            BuildBatch(
                []*transaction_pb2.Transaction{trn},
                snr),
        },
    }

    serialised := batchList.String()

    fmt.Println(serialised)

    resp, err := http.Post(
        restAPI+"/batches",
        "application/octet-stream",
        bytes.NewReader([]byte(serialised)),
    )

    if err != nil {
        fmt.Println("Error")
        fmt.Println(err.Error())
        return
    }

    defer resp.Body.Close()
    fmt.Println(resp.Status)
    body, err := ioutil.ReadAll(resp.Body)
    fmt.Println(string(body))
    elapsed := time.Since(s)
    log.Printf("Creation took %s", elapsed)

    resp.Close = true
}

// BuildTransaction will build a transaction based on the information provided
func BuildTransaction(ID, payload, familyName, familyVersion string, snr *signing.Signer) *transaction_pb2.Transaction {
    publicKeyHex := snr.GetPublicKey().AsHex()
    payloadHash := Hexdigest(string(payload))

    addr := Hexdigest(familyName)[:6] + Hexdigest(ID)[:64]

    transactionHeader := &transaction_pb2.TransactionHeader{
        FamilyName:       familyName,
        FamilyVersion:    familyVersion,
        SignerPublicKey:  publicKeyHex,
        BatcherPublicKey: publicKeyHex,
        Inputs:           []string{addr},
        Outputs:          []string{addr},
        Dependencies:     []string{},
        PayloadSha512:    payloadHash,
        Nonce:            GenerateNonce(),
    }

    header := transactionHeader.String()
    headerBytes := []byte(header)
    headerSig := hex.EncodeToString(snr.Sign(headerBytes))

    return &transaction_pb2.Transaction{
        Header:          headerBytes,
        HeaderSignature: headerSig[:64],
        Payload:         []byte(payload),
    }
}

// BuildBatch will build a batch using the provided transactions
func BuildBatch(trans []*transaction_pb2.Transaction, snr *signing.Signer) *batch_pb2.Batch {

    ids := []string{}

    for _, t := range trans {
        ids = append(ids, t.HeaderSignature)
    }

    batchHeader := &batch_pb2.BatchHeader{
        SignerPublicKey: snr.GetPublicKey().AsHex(),
        TransactionIds:  ids,
    }

    return &batch_pb2.Batch{
        Header:          []byte(batchHeader.String()),
        HeaderSignature: hex.EncodeToString(snr.Sign([]byte(batchHeader.String())))[:64],
        Transactions:    trans,
    }
}

// Hexdigest will hash the string and return the result as hex
func Hexdigest(str string) string {
    hash := sha512.New()
    hash.Write([]byte(str))
    hashBytes := hash.Sum(nil)
    return strings.ToLower(hex.EncodeToString(hashBytes))
}

// GenerateNonce will generate a random string to use
func GenerateNonce() string {
    return randStringBytesMaskImprSrc(16)
}

const (
    letterBytes   = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
    letterIdxBits = 6                    // 6 bits to represent a letter index
    letterIdxMask = 1<<letterIdxBits - 1 // All 1-bits, as many as letterIdxBits
    letterIdxMax  = 63 / letterIdxBits   // # of letter indices fitting in 63 bits
)

func randStringBytesMaskImprSrc(n int) string {
    rand.Seed(time.Now().UnixNano())
    b := make([]byte, n)
    // A rand.Int63() generates 63 random bits, enough for letterIdxMax letters!
    for i, cache, remain := n-1, rand.Int63(), letterIdxMax; i >= 0; {
        if remain == 0 {
            cache, remain = rand.Int63(), letterIdxMax
        }
        if idx := int(cache & letterIdxMask); idx < len(letterBytes) {
            b[i] = letterBytes[idx]
            i--
        }
        cache >>= letterIdxBits
        remain--
    }

    return string(b)
}

Answer 1

这方面存在很多问题，希望我能够单独解释每个问题，以帮助阐明这些事务可能失败的方式。

交易完整性

正如 @Frank C. 上面的评论，我的交易 header 缺少几个值。这些是地址，也是随机数。

// Hexdigest will hash the string and return the result as hex
func Hexdigest(str string) string {
    hash := sha512.New()
    hash.Write([]byte(str))
    hashBytes := hash.Sum(nil)
    return strings.ToLower(hex.EncodeToString(hashBytes))
}


addr := Hexdigest(familyName)[:6] + Hexdigest(ID)[:64]
transactionHeader := &transaction_pb2.TransactionHeader{
    FamilyName:       familyName,
    FamilyVersion:    familyVersion,
    SignerPublicKey:  publicKeyHex,
    BatcherPublicKey: publicKeyHex,
    Inputs:           []string{addr},
    Outputs:          []string{addr},
    Dependencies:     []string{},
    PayloadSha512:    payloadHash,
    Nonce:            uuid.NewV4(),
} 

追踪

下一步是在批处理中启用跟踪。

return &batch_pb2.Batch{
    Header:          []byte(batchHeader.String()),
    HeaderSignature: batchHeaderSignature,
    Transactions:    trans,
    Trace: true, // Set this flag to true
}

通过上述设置，Rest API 将解码消息以打印其他日志记录信息，并且 Validator 组件将输出更有用的日志记录。

400 Bad Request
{
"error": {
"code": 35,
"message": "The protobuf BatchList you submitted was malformed and could not be read.",
"title": "Protobuf Not Decodable"
}
}

打开跟踪后，Rest API 会输出以上内容。这证明接收到的数据有问题。

为什么会出现这种情况？
根据 Sawtooth 聊天室的一些宝贵建议，我尝试使用另一种语言的 SDK 反序列化我的批处理。

反序列化

为了测试在另一个 SDK 中反序列化批处理，我在 python 中构建了一个 Web api，我可以轻松地将批处理发送到该 API，从而尝试反序列化它们。

from flask import Flask, request

from protobuf import batch_pb2

app = Flask(__name__)

@app.route("/batches", methods = [ 'POST' ])
def deserialise():
    received = request.data
    print(received)
    print("\n")
    print(''.join('{:02x}'.format(x) for x in received))

    batchlist = batch_pb2.BatchList()

    batchlist.ParseFromString(received)
    return ""

if __name__ == '__main__':
    app.run(host="0.0.0.0", debug=True)

将我的批处理发送到此后，我收到以下错误。

RuntimeWarning: Unexpected end-group tag: Not all data was converted

这显然是我的批处理出了问题，但由于这一切都是由 Hyperledger Sawtooth Go SDK 处理的，我决定转向 Python 并用它构建我的应用程序。