github.com/myafeier/fabric@v1.0.1-0.20170722181825-3a4b1f2bce86/orderer/common/multichannel/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 multichannel
    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) Errored() <-chan struct{} {
    52  	return nil
    53  }
    54  
    55  func (mch *mockChain) Enqueue(env *cb.Envelope) bool {
    56  	mch.queue <- env
    57  	return true
    58  }
    59  
    60  func (mch *mockChain) Start() {
    61  	go func() {
    62  		defer close(mch.done)
    63  		for {
    64  			msg, ok := <-mch.queue
    65  			if !ok {
    66  				return
    67  			}
    68  
    69  			class, err := mch.support.ClassifyMsg(msg)
    70  			if err != nil {
    71  				logger.Panicf("If a message has arrived to this point, it should already have been classified once")
    72  			}
    73  			switch class {
    74  			case ConfigUpdateMsg:
    75  				batch := mch.support.BlockCutter().Cut()
    76  				if batch != nil {
    77  					block := mch.support.CreateNextBlock(batch)
    78  					mch.support.WriteBlock(block, nil)
    79  				}
    80  
    81  				_, err := mch.support.ProcessNormalMsg(msg)
    82  				if err != nil {
    83  					logger.Warningf("Discarding bad config message: %s", err)
    84  					continue
    85  				}
    86  				block := mch.support.CreateNextBlock([]*cb.Envelope{msg})
    87  				mch.support.WriteConfigBlock(block, nil)
    88  			case NormalMsg:
    89  				batches, _ := mch.support.BlockCutter().Ordered(msg)
    90  				for _, batch := range batches {
    91  					block := mch.support.CreateNextBlock(batch)
    92  					mch.support.WriteBlock(block, nil)
    93  				}
    94  			default:
    95  				logger.Panicf("Unsupported msg classification: %v", class)
    96  			}
    97  		}
    98  	}()
    99  }
   100  
   101  func (mch *mockChain) Halt() {
   102  	close(mch.queue)
   103  }
   104  
   105  func makeConfigTx(chainID string, i int) *cb.Envelope {
   106  	group := cb.NewConfigGroup()
   107  	group.Groups[config.OrdererGroupKey] = cb.NewConfigGroup()
   108  	group.Groups[config.OrdererGroupKey].Values[fmt.Sprintf("%d", i)] = &cb.ConfigValue{
   109  		Value: []byte(fmt.Sprintf("%d", i)),
   110  	}
   111  	configTemplate := configtx.NewSimpleTemplate(group)
   112  	configEnv, err := configTemplate.Envelope(chainID)
   113  	if err != nil {
   114  		panic(err)
   115  	}
   116  	return makeConfigTxFromConfigUpdateEnvelope(chainID, configEnv)
   117  }
   118  
   119  func wrapConfigTx(env *cb.Envelope) *cb.Envelope {
   120  	result, err := utils.CreateSignedEnvelope(cb.HeaderType_ORDERER_TRANSACTION, provisional.TestChainID, mockCrypto(), env, msgVersion, epoch)
   121  	if err != nil {
   122  		panic(err)
   123  	}
   124  	return result
   125  }
   126  
   127  func makeConfigTxFromConfigUpdateEnvelope(chainID string, configUpdateEnv *cb.ConfigUpdateEnvelope) *cb.Envelope {
   128  	configUpdateTx, err := utils.CreateSignedEnvelope(cb.HeaderType_CONFIG_UPDATE, chainID, mockCrypto(), configUpdateEnv, msgVersion, epoch)
   129  	if err != nil {
   130  		panic(err)
   131  	}
   132  	configTx, err := utils.CreateSignedEnvelope(cb.HeaderType_CONFIG, chainID, mockCrypto(), &cb.ConfigEnvelope{
   133  		Config:     &cb.Config{Sequence: 1, ChannelGroup: configtx.UnmarshalConfigUpdateOrPanic(configUpdateEnv.ConfigUpdate).WriteSet},
   134  		LastUpdate: configUpdateTx},
   135  		msgVersion, epoch)
   136  	if err != nil {
   137  		panic(err)
   138  	}
   139  	return configTx
   140  }
   141  
   142  func makeNormalTx(chainID string, i int) *cb.Envelope {
   143  	payload := &cb.Payload{
   144  		Header: &cb.Header{
   145  			ChannelHeader: utils.MarshalOrPanic(&cb.ChannelHeader{
   146  				Type:      int32(cb.HeaderType_ENDORSER_TRANSACTION),
   147  				ChannelId: chainID,
   148  			}),
   149  			SignatureHeader: utils.MarshalOrPanic(&cb.SignatureHeader{}),
   150  		},
   151  		Data: []byte(fmt.Sprintf("%d", i)),
   152  	}
   153  	return &cb.Envelope{
   154  		Payload: utils.MarshalOrPanic(payload),
   155  	}
   156  }