github.com/adnan-c/fabric_e2e_couchdb@v0.6.1-preview.0.20170228180935-21ce6b23cf91/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/configtx"
    23  	"github.com/hyperledger/fabric/common/configtx/tool/provisional"
    24  	configtxorderer "github.com/hyperledger/fabric/common/configvalues/channel/orderer"
    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  const (
    31  	msgVersion = int32(0)
    32  	epoch      = uint64(0)
    33  )
    34  
    35  type mockConsenter struct {
    36  }
    37  
    38  func (mc *mockConsenter) HandleChain(support ConsenterSupport, metadata *cb.Metadata) (Chain, error) {
    39  	return &mockChain{
    40  		queue:    make(chan *cb.Envelope),
    41  		cutter:   support.BlockCutter(),
    42  		support:  support,
    43  		metadata: metadata,
    44  		done:     make(chan struct{}),
    45  	}, nil
    46  }
    47  
    48  type mockChain struct {
    49  	queue    chan *cb.Envelope
    50  	cutter   blockcutter.Receiver
    51  	support  ConsenterSupport
    52  	metadata *cb.Metadata
    53  	done     chan struct{}
    54  }
    55  
    56  func (mch *mockChain) Enqueue(env *cb.Envelope) bool {
    57  	mch.queue <- env
    58  	return true
    59  }
    60  
    61  func (mch *mockChain) Start() {
    62  	go func() {
    63  		defer close(mch.done)
    64  		for {
    65  			msg, ok := <-mch.queue
    66  			if !ok {
    67  				return
    68  			}
    69  			batches, committers, _ := mch.cutter.Ordered(msg)
    70  			for i, batch := range batches {
    71  				block := mch.support.CreateNextBlock(batch)
    72  				mch.support.WriteBlock(block, committers[i], nil)
    73  			}
    74  		}
    75  	}()
    76  }
    77  
    78  func (mch *mockChain) Halt() {
    79  	close(mch.queue)
    80  }
    81  
    82  type mockLedgerWriter struct {
    83  }
    84  
    85  func (mlw *mockLedgerWriter) Append(blockContents []*cb.Envelope, metadata [][]byte) *cb.Block {
    86  	logger.Debugf("Committed block")
    87  	return nil
    88  }
    89  
    90  func makeConfigTx(chainID string, i int) *cb.Envelope {
    91  	group := cb.NewConfigGroup()
    92  	group.Groups[configtxorderer.GroupKey] = cb.NewConfigGroup()
    93  	group.Groups[configtxorderer.GroupKey].Values[fmt.Sprintf("%d", i)] = &cb.ConfigValue{
    94  		Value: []byte(fmt.Sprintf("%d", i)),
    95  	}
    96  	configTemplate := configtx.NewSimpleTemplate(group)
    97  	configEnv, err := configTemplate.Envelope(chainID)
    98  	if err != nil {
    99  		panic(err)
   100  	}
   101  	return makeConfigTxFromConfigUpdateEnvelope(chainID, configEnv)
   102  }
   103  
   104  func wrapConfigTx(env *cb.Envelope) *cb.Envelope {
   105  	result, err := utils.CreateSignedEnvelope(cb.HeaderType_ORDERER_TRANSACTION, provisional.TestChainID, mockCrypto(), env, msgVersion, epoch)
   106  	if err != nil {
   107  		panic(err)
   108  	}
   109  	return result
   110  }
   111  
   112  func makeConfigTxFromConfigUpdateEnvelope(chainID string, configUpdateEnv *cb.ConfigUpdateEnvelope) *cb.Envelope {
   113  	configUpdateTx, err := utils.CreateSignedEnvelope(cb.HeaderType_CONFIG_UPDATE, chainID, mockCrypto(), configUpdateEnv, msgVersion, epoch)
   114  	if err != nil {
   115  		panic(err)
   116  	}
   117  	configTx, err := utils.CreateSignedEnvelope(cb.HeaderType_CONFIG, chainID, mockCrypto(), &cb.ConfigEnvelope{
   118  		Config:     &cb.Config{Header: &cb.ChannelHeader{ChannelId: chainID}, Channel: configtx.UnmarshalConfigUpdateOrPanic(configUpdateEnv.ConfigUpdate).WriteSet},
   119  		LastUpdate: configUpdateTx},
   120  		msgVersion, epoch)
   121  	if err != nil {
   122  		panic(err)
   123  	}
   124  	return configTx
   125  }
   126  
   127  func makeNormalTx(chainID string, i int) *cb.Envelope {
   128  	payload := &cb.Payload{
   129  		Header: &cb.Header{
   130  			ChannelHeader: utils.MarshalOrPanic(&cb.ChannelHeader{
   131  				Type:      int32(cb.HeaderType_ENDORSER_TRANSACTION),
   132  				ChannelId: chainID,
   133  			}),
   134  			SignatureHeader: utils.MarshalOrPanic(&cb.SignatureHeader{}),
   135  		},
   136  		Data: []byte(fmt.Sprintf("%d", i)),
   137  	}
   138  	return &cb.Envelope{
   139  		Payload: utils.MarshalOrPanic(payload),
   140  	}
   141  }
   142  
   143  func makeSignaturelessTx(chainID string, i int) *cb.Envelope {
   144  	payload := &cb.Payload{
   145  		Header: &cb.Header{
   146  			ChannelHeader: utils.MarshalOrPanic(&cb.ChannelHeader{
   147  				Type:      int32(cb.HeaderType_ENDORSER_TRANSACTION),
   148  				ChannelId: chainID,
   149  			}),
   150  		},
   151  		Data: []byte(fmt.Sprintf("%d", i)),
   152  	}
   153  	return &cb.Envelope{
   154  		Payload: utils.MarshalOrPanic(payload),
   155  	}
   156  }