github.com/leonlxy/hyperledger@v1.0.0-alpha.0.20170427033203-34922035d248/orderer/multichain/util_test.go (about)

     1  /*
     2  Copyright IBM Corp. 2016 All Rights Reserved.
     3  
     4  Licensed under the Apache License, Version 2.0 (the "License");
     5  you may not use this file except in compliance with the License.
     6  You may obtain a copy of the License at
     7  
     8                   http://www.apache.org/licenses/LICENSE-2.0
     9  
    10  Unless required by applicable law or agreed to in writing, software
    11  distributed under the License is distributed on an "AS IS" BASIS,
    12  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    13  See the License for the specific language governing permissions and
    14  limitations under the License.
    15  */
    16  
    17  package multichain
    18  
    19  import (
    20  	"fmt"
    21  
    22  	"github.com/hyperledger/fabric/common/config"
    23  	"github.com/hyperledger/fabric/common/configtx"
    24  	"github.com/hyperledger/fabric/common/configtx/tool/provisional"
    25  	"github.com/hyperledger/fabric/orderer/common/blockcutter"
    26  	cb "github.com/hyperledger/fabric/protos/common"
    27  	"github.com/hyperledger/fabric/protos/utils"
    28  )
    29  
    30  type mockConsenter struct {
    31  }
    32  
    33  func (mc *mockConsenter) HandleChain(support ConsenterSupport, metadata *cb.Metadata) (Chain, error) {
    34  	return &mockChain{
    35  		queue:    make(chan *cb.Envelope),
    36  		cutter:   support.BlockCutter(),
    37  		support:  support,
    38  		metadata: metadata,
    39  		done:     make(chan struct{}),
    40  	}, nil
    41  }
    42  
    43  type mockChain struct {
    44  	queue    chan *cb.Envelope
    45  	cutter   blockcutter.Receiver
    46  	support  ConsenterSupport
    47  	metadata *cb.Metadata
    48  	done     chan struct{}
    49  }
    50  
    51  func (mch *mockChain) Enqueue(env *cb.Envelope) bool {
    52  	mch.queue <- env
    53  	return true
    54  }
    55  
    56  func (mch *mockChain) Start() {
    57  	go func() {
    58  		defer close(mch.done)
    59  		for {
    60  			msg, ok := <-mch.queue
    61  			if !ok {
    62  				return
    63  			}
    64  			batches, committers, _ := mch.cutter.Ordered(msg)
    65  			for i, batch := range batches {
    66  				block := mch.support.CreateNextBlock(batch)
    67  				mch.support.WriteBlock(block, committers[i], nil)
    68  			}
    69  		}
    70  	}()
    71  }
    72  
    73  func (mch *mockChain) Halt() {
    74  	close(mch.queue)
    75  }
    76  
    77  type mockLedgerWriter struct {
    78  }
    79  
    80  func (mlw *mockLedgerWriter) Append(blockContents []*cb.Envelope, metadata [][]byte) *cb.Block {
    81  	logger.Debugf("Committed block")
    82  	return nil
    83  }
    84  
    85  func makeConfigTx(chainID string, i int) *cb.Envelope {
    86  	group := cb.NewConfigGroup()
    87  	group.Groups[config.OrdererGroupKey] = cb.NewConfigGroup()
    88  	group.Groups[config.OrdererGroupKey].Values[fmt.Sprintf("%d", i)] = &cb.ConfigValue{
    89  		Value: []byte(fmt.Sprintf("%d", i)),
    90  	}
    91  	configTemplate := configtx.NewSimpleTemplate(group)
    92  	configEnv, err := configTemplate.Envelope(chainID)
    93  	if err != nil {
    94  		panic(err)
    95  	}
    96  	return makeConfigTxFromConfigUpdateEnvelope(chainID, configEnv)
    97  }
    98  
    99  func wrapConfigTx(env *cb.Envelope) *cb.Envelope {
   100  	result, err := utils.CreateSignedEnvelope(cb.HeaderType_ORDERER_TRANSACTION, provisional.TestChainID, mockCrypto(), env, msgVersion, epoch)
   101  	if err != nil {
   102  		panic(err)
   103  	}
   104  	return result
   105  }
   106  
   107  func makeConfigTxFromConfigUpdateEnvelope(chainID string, configUpdateEnv *cb.ConfigUpdateEnvelope) *cb.Envelope {
   108  	configUpdateTx, err := utils.CreateSignedEnvelope(cb.HeaderType_CONFIG_UPDATE, chainID, mockCrypto(), configUpdateEnv, msgVersion, epoch)
   109  	if err != nil {
   110  		panic(err)
   111  	}
   112  	configTx, err := utils.CreateSignedEnvelope(cb.HeaderType_CONFIG, chainID, mockCrypto(), &cb.ConfigEnvelope{
   113  		Config:     &cb.Config{Sequence: 1, ChannelGroup: configtx.UnmarshalConfigUpdateOrPanic(configUpdateEnv.ConfigUpdate).WriteSet},
   114  		LastUpdate: configUpdateTx},
   115  		msgVersion, epoch)
   116  	if err != nil {
   117  		panic(err)
   118  	}
   119  	return configTx
   120  }
   121  
   122  func makeNormalTx(chainID string, i int) *cb.Envelope {
   123  	payload := &cb.Payload{
   124  		Header: &cb.Header{
   125  			ChannelHeader: utils.MarshalOrPanic(&cb.ChannelHeader{
   126  				Type:      int32(cb.HeaderType_ENDORSER_TRANSACTION),
   127  				ChannelId: chainID,
   128  			}),
   129  			SignatureHeader: utils.MarshalOrPanic(&cb.SignatureHeader{}),
   130  		},
   131  		Data: []byte(fmt.Sprintf("%d", i)),
   132  	}
   133  	return &cb.Envelope{
   134  		Payload: utils.MarshalOrPanic(payload),
   135  	}
   136  }
   137  
   138  func makeSignaturelessTx(chainID string, i int) *cb.Envelope {
   139  	payload := &cb.Payload{
   140  		Header: &cb.Header{
   141  			ChannelHeader: utils.MarshalOrPanic(&cb.ChannelHeader{
   142  				Type:      int32(cb.HeaderType_ENDORSER_TRANSACTION),
   143  				ChannelId: chainID,
   144  			}),
   145  		},
   146  		Data: []byte(fmt.Sprintf("%d", i)),
   147  	}
   148  	return &cb.Envelope{
   149  		Payload: utils.MarshalOrPanic(payload),
   150  	}
   151  }