fabric-sdk-go: github.com/hyperledger/fabric-sdk-go/pkg/client/resmgmt Index | Examples | Files

package resmgmt

import "github.com/hyperledger/fabric-sdk-go/pkg/client/resmgmt"

Code generated by counterfeiter. DO NOT EDIT.

Code generated by counterfeiter. DO NOT EDIT.

Code generated by counterfeiter. DO NOT EDIT.

Code generated by counterfeiter. DO NOT EDIT.

Package resmgmt enables creation and update of resources on a Fabric network. It allows administrators to create and/or update channnels, and for peers to join channels. Administrators can also perform chaincode related operations on a peer, such as installing, instantiating, and upgrading chaincode.

Basic Flow:
1) Prepare client context
2) Create resource managememt client
3) Create new channel
4) Peer(s) join channel
5) Install chaincode onto peer(s) filesystem
6) Instantiate chaincode on channel
7) Query peer for channels, installed/instantiated chaincodes etc.

Code:

// Create new resource management client
c, err := New(mockClientProvider())
if err != nil {
    fmt.Println("failed to create client")
}

// Read channel configuration tx
channelConfigTxPath := filepath.Join(metadata.GetProjectPath(), metadata.ChannelConfigPath, channelConfigTxFile)
r, err := os.Open(channelConfigTxPath)
if err != nil {
    fmt.Printf("failed to open channel config: %s\n", err)
}
defer r.Close()

// Create new channel 'mychannel'
_, err = c.SaveChannel(SaveChannelRequest{ChannelID: "mychannel", ChannelConfig: r})
if err != nil {
    fmt.Printf("failed to save channel: %s\n", err)
}

peer := mockPeer()

// Peer joins channel 'mychannel'
err = c.JoinChannel("mychannel", WithTargets(peer))
if err != nil {
    fmt.Printf("failed to join channel: %s\n", err)
}

// Install example chaincode to peer
installReq := InstallCCRequest{Name: "ExampleCC", Version: "v0", Path: "path", Package: &resource.CCPackage{Type: 1, Code: []byte("bytes")}}
_, err = c.InstallCC(installReq, WithTargets(peer))
if err != nil {
    fmt.Printf("failed to install chaincode: %s\n", err)
}

// Instantiate example chaincode on channel 'mychannel'
ccPolicy := policydsl.SignedByMspMember("Org1MSP")
instantiateReq := InstantiateCCRequest{Name: "ExampleCC", Version: "v0", Path: "path", Policy: ccPolicy}
_, err = c.InstantiateCC("mychannel", instantiateReq, WithTargets(peer))
if err != nil {
    fmt.Printf("failed to install chaincode: %s\n", err)
}

fmt.Println("Network setup completed")

Output:

Network setup completed

Index

Examples

Package Files

lifecycleclient.go lifecycleprocessor.go lscc.go mockchannelprovider.gen.go mockchannelservice.gen.go mocklifecycleresource.gen.go mocktransactor.gen.go opts.go resmgmt.go

Constants

const (
    InstantiateChaincode chaincodeProposalType = iota
    UpgradeChaincode
)

Define chaincode proposal types

func CalculateConfigUpdate Uses

func CalculateConfigUpdate(channelID string, currentConfig, newConfig *common.Config) (*common.ConfigUpdate, error)

CalculateConfigUpdate calculates channel config update based on the difference between provided current channel config and proposed new channel config.

func MarshalConfigSignature Uses

func MarshalConfigSignature(signature *common.ConfigSignature) ([]byte, error)

MarshalConfigSignature marshals 1 ConfigSignature for the given client concatenated as []byte

func UnmarshalConfigSignature Uses

func UnmarshalConfigSignature(reader io.Reader) (*common.ConfigSignature, error)

UnmarshalConfigSignature reads 1 ConfigSignature as []byte from reader and unmarshals it

type CCReference Uses

type CCReference struct {
    Name    string `json:"name,omitempty"`
    Version string `json:"version,omitempty"`
}

CCReference contains the name and version of an instantiated chaincode that references the installed chaincode package.

type Client Uses

type Client struct {
    // contains filtered or unexported fields
}

Client enables managing resources in Fabric network.

func New Uses

func New(ctxProvider context.ClientProvider, opts ...ClientOption) (*Client, error)

New returns a resource management client instance.

Code:

ctx := mockClientProvider()

c, err := New(ctx)
if err != nil {
    fmt.Println("failed to create client")
}

if c != nil {
    fmt.Println("resource management client created")
}

Output:

resource management client created

func (*Client) CreateConfigSignature Uses

func (rc *Client) CreateConfigSignature(signer msp.SigningIdentity, channelConfigPath string) (*common.ConfigSignature, error)

CreateConfigSignature creates a signature for the given client, custom signers and chConfig from channelConfigPath argument

return ConfigSignature will be signed internally by the SDK. It can be passed to WithConfigSignatures() option

Deprecated: this method is deprecated in order to use CreateConfigSignatureFromReader

func (*Client) CreateConfigSignatureData Uses

func (rc *Client) CreateConfigSignatureData(signer msp.SigningIdentity, channelConfigPath string) (signatureHeaderData resource.ConfigSignatureData, e error)

CreateConfigSignatureData will prepare a SignatureHeader and the full signing []byte (signingBytes) to be used for signing a Channel Config Deprecated: this method is deprecated in order to use CreateConfigSignatureDataFromReader

func (*Client) CreateConfigSignatureDataFromReader Uses

func (rc *Client) CreateConfigSignatureDataFromReader(signer msp.SigningIdentity, channelConfig io.Reader) (signatureHeaderData resource.ConfigSignatureData, e error)

CreateConfigSignatureDataFromReader will prepare a SignatureHeader and the full signing []byte (signingBytes) to be used for signing a Channel Config

	Once SigningBytes have been signed externally (signing signatureHeaderData.SigningBytes using an external tool like OpenSSL), do the following:
 1. create a common.ConfigSignature{} instance
 2. assign its SignatureHeader field with the returned field 'signatureHeaderData.signatureHeader'
 3. assign its Signature field with the generated signature of 'signatureHeaderData.signingBytes' from the external tool
 Then use WithConfigSignatures() option to pass this new instance for channel updates

func (*Client) CreateConfigSignatureFromReader Uses

func (rc *Client) CreateConfigSignatureFromReader(signer msp.SigningIdentity, channelConfig io.Reader) (*common.ConfigSignature, error)

CreateConfigSignatureFromReader creates a signature for the given client, custom signers and chConfig from io.Reader argument

return ConfigSignature will be signed internally by the SDK. It can be passed to WithConfigSignatures() option

func (*Client) InstallCC Uses

func (rc *Client) InstallCC(req InstallCCRequest, options ...RequestOption) ([]InstallCCResponse, error)

InstallCC allows administrators to install chaincode onto the filesystem of a peer. If peer(s) are not specified in options it will default to all peers that belong to admin's MSP.

Parameters:
req holds info about mandatory chaincode name, path, version and policy
options holds optional request options

Returns:
install chaincode proposal responses from peer(s)

Code:

c, err := New(mockClientProvider())
if err != nil {
    fmt.Println("failed to create client")
}

req := InstallCCRequest{Name: "ExampleCC", Version: "v0", Path: "path", Package: &resource.CCPackage{Type: 1, Code: []byte("bytes")}}
responses, err := c.InstallCC(req, WithTargets(mockPeer()))
if err != nil {
    fmt.Printf("failed to install chaincode: %s\n", err)
}

if len(responses) > 0 {
    fmt.Println("Chaincode installed")
}

Output:

Chaincode installed

func (*Client) InstantiateCC Uses

func (rc *Client) InstantiateCC(channelID string, req InstantiateCCRequest, options ...RequestOption) (InstantiateCCResponse, error)

InstantiateCC instantiates chaincode with optional custom options (specific peers, filtered peers, timeout). If peer(s) are not specified in options it will default to all channel peers.

Parameters:
channel is manadatory channel name
req holds info about mandatory chaincode name, path, version and policy
options holds optional request options

Returns:
instantiate chaincode response with transaction ID

Code:

c, err := New(mockClientProvider())
if err != nil {
    fmt.Println("failed to create client")
}

ccPolicy := policydsl.SignedByMspMember("Org1MSP")
req := InstantiateCCRequest{Name: "ExampleCC", Version: "v0", Path: "path", Policy: ccPolicy}

resp, err := c.InstantiateCC("mychannel", req)
if err != nil {
    fmt.Printf("failed to install chaincode: %s\n", err)
}

if resp.TransactionID == "" {
    fmt.Println("Failed to instantiate chaincode")
}

fmt.Println("Chaincode instantiated")

Output:

Chaincode instantiated

func (*Client) JoinChannel Uses

func (rc *Client) JoinChannel(channelID string, options ...RequestOption) error

JoinChannel allows for peers to join existing channel with optional custom options (specific peers, filtered peers). If peer(s) are not specified in options it will default to all peers that belong to client's MSP.

Parameters:
channel is manadatory channel name
options holds optional request options

Returns:
an error if join fails

Code:

c, err := New(mockClientProvider())
if err != nil {
    fmt.Println("failed to create client")
}

err = c.JoinChannel("mychannel", WithTargets(mockPeer()))
if err != nil {
    fmt.Printf("failed to join channel: %s\n", err)
}

fmt.Println("Joined channel")

Output:

Joined channel

func (*Client) LifecycleApproveCC Uses

func (rc *Client) LifecycleApproveCC(channelID string, req LifecycleApproveCCRequest, options ...RequestOption) (fab.TransactionID, error)

LifecycleApproveCC approves a chaincode for an organization.

func (*Client) LifecycleCheckCCCommitReadiness Uses

func (rc *Client) LifecycleCheckCCCommitReadiness(channelID string, req LifecycleCheckCCCommitReadinessRequest, options ...RequestOption) (LifecycleCheckCCCommitReadinessResponse, error)

LifecycleCheckCCCommitReadiness checks the 'commit readiness' of a chaincode. Returned are the org approvals.

func (*Client) LifecycleCommitCC Uses

func (rc *Client) LifecycleCommitCC(channelID string, req LifecycleCommitCCRequest, options ...RequestOption) (fab.TransactionID, error)

LifecycleCommitCC commits the chaincode to the given channel

func (*Client) LifecycleGetInstalledCCPackage Uses

func (rc *Client) LifecycleGetInstalledCCPackage(packageID string, options ...RequestOption) ([]byte, error)

LifecycleGetInstalledCCPackage retrieves the installed chaincode package for the given package ID. NOTE: The package ID may be computed with fab/ccpackager/lifecycle.ComputePackageID.

func (*Client) LifecycleInstallCC Uses

func (rc *Client) LifecycleInstallCC(req LifecycleInstallCCRequest, options ...RequestOption) ([]LifecycleInstallCCResponse, error)

LifecycleInstallCC installs a chaincode package using Fabric 2.0 chaincode lifecycle.

func (*Client) LifecycleQueryApprovedCC Uses

func (rc *Client) LifecycleQueryApprovedCC(channelID string, req LifecycleQueryApprovedCCRequest, options ...RequestOption) (LifecycleApprovedChaincodeDefinition, error)

LifecycleQueryApprovedCC returns information about the approved chaincode definition

func (*Client) LifecycleQueryCommittedCC Uses

func (rc *Client) LifecycleQueryCommittedCC(channelID string, req LifecycleQueryCommittedCCRequest, options ...RequestOption) ([]LifecycleChaincodeDefinition, error)

LifecycleQueryCommittedCC queries for committed chaincodes on a given channel

func (*Client) LifecycleQueryInstalledCC Uses

func (rc *Client) LifecycleQueryInstalledCC(options ...RequestOption) ([]LifecycleInstalledCC, error)

LifecycleQueryInstalledCC returns the chaincodes that were installed on a given peer with Fabric 2.0 chaincode lifecycle.

func (*Client) QueryChannels Uses

func (rc *Client) QueryChannels(options ...RequestOption) (*pb.ChannelQueryResponse, error)

QueryChannels queries the names of all the channels that a peer has joined.

Parameters:
options hold optional request options
Note: One target(peer) has to be specified using either WithTargetURLs or WithTargets request option

Returns:
all channels that peer has joined

Code:

c, err := New(mockClientProvider())
if err != nil {
    fmt.Println("failed to create client")
}

response, err := c.QueryChannels(WithTargets(mockPeer()))
if err != nil {
    fmt.Printf("failed to query channels: %s\n", err)
}

if response != nil {
    fmt.Println("Retrieved channels")
}

Output:

Retrieved channels

func (*Client) QueryCollectionsConfig Uses

func (rc *Client) QueryCollectionsConfig(channelID string, chaincodeName string, options ...RequestOption) (*pb.CollectionConfigPackage, error)

QueryCollectionsConfig queries the collections config on a peer for specific channel. If peer is not specified in options it will query random peer on this channel. Parameters: channel is mandatory channel name chaincode is mandatory chaincode name options hold optional request options

Returns: list of collections config

func (*Client) QueryConfigBlockFromOrderer Uses

func (rc *Client) QueryConfigBlockFromOrderer(channelID string, options ...RequestOption) (*common.Block, error)

QueryConfigBlockFromOrderer config returns channel configuration block from orderer. If orderer is not provided using options it will be defaulted to channel orderer (if configured) or random orderer from configuration.

Parameters:
channelID is mandatory channel ID
options holds optional request options

Returns:
channel configuration block

func (*Client) QueryConfigFromOrderer Uses

func (rc *Client) QueryConfigFromOrderer(channelID string, options ...RequestOption) (fab.ChannelCfg, error)

QueryConfigFromOrderer config returns channel configuration from orderer. If orderer is not provided using options it will be defaulted to channel orderer (if configured) or random orderer from configuration.

Parameters:
channelID is mandatory channel ID
options holds optional request options

Returns:
channel configuration

func (*Client) QueryInstalledChaincodes Uses

func (rc *Client) QueryInstalledChaincodes(options ...RequestOption) (*pb.ChaincodeQueryResponse, error)

QueryInstalledChaincodes queries the installed chaincodes on a peer.

Parameters:
options hold optional request options
Note: One target(peer) has to be specified using either WithTargetURLs or WithTargets request option

Returns:
list of installed chaincodes on specified peer

Code:

c, err := New(mockClientProvider())
if err != nil {
    fmt.Println("failed to create client")
}

response, err := c.QueryInstalledChaincodes(WithTargets(mockPeer()))
if err != nil {
    fmt.Printf("failed to query installed chaincodes: %s\n", err)
}

if response != nil {
    fmt.Println("Retrieved installed chaincodes")
}

Output:

Retrieved installed chaincodes

func (*Client) QueryInstantiatedChaincodes Uses

func (rc *Client) QueryInstantiatedChaincodes(channelID string, options ...RequestOption) (*pb.ChaincodeQueryResponse, error)

QueryInstantiatedChaincodes queries the instantiated chaincodes on a peer for specific channel. If peer is not specified in options it will query random peer on this channel.

Parameters:
channel is manadatory channel name
options hold optional request options

Returns:
list of instantiated chaincodes

Code:

c, err := New(mockClientProvider())
if err != nil {
    fmt.Println("failed to create client")
}

response, err := c.QueryInstantiatedChaincodes("mychannel", WithTargets(mockPeer()))
if err != nil {
    fmt.Printf("failed to query instantiated chaincodes: %s\n", err)
}

if response != nil {
    fmt.Println("Retrieved instantiated chaincodes")
}

Output:

Retrieved instantiated chaincodes

func (*Client) SaveChannel Uses

func (rc *Client) SaveChannel(req SaveChannelRequest, options ...RequestOption) (SaveChannelResponse, error)

SaveChannel creates or updates channel.

 Parameters:
 req holds info about mandatory channel name and configuration
 options holds optional request options
 if options have signatures (WithConfigSignatures() or 1 or more WithConfigSignature() calls), then SaveChannel will
    use these signatures instead of creating ones for the SigningIdentities found in req.
	   Make sure that req.ChannelConfigPath/req.ChannelConfig have the channel config matching these signatures.

 Returns:
 save channel response with transaction ID

Code:

c, err := New(mockClientProvider())
if err != nil {
    fmt.Printf("failed to create client: %s\n", err)
}

channelConfigTxPath := filepath.Join(metadata.GetProjectPath(), metadata.ChannelConfigPath, channelConfigTxFile)
r, err := os.Open(channelConfigTxPath)
if err != nil {
    fmt.Printf("failed to open channel config: %s\n", err)
}
defer r.Close()

resp, err := c.SaveChannel(SaveChannelRequest{ChannelID: "mychannel", ChannelConfig: r})
if err != nil {
    fmt.Printf("failed to save channel: %s\n", err)
}

if resp.TransactionID == "" {
    fmt.Println("Failed to save channel")
}

fmt.Println("Saved channel")

Output:

Saved channel

Code:

c, err := New(mockClientProvider())
if err != nil {
    fmt.Printf("failed to create client: %s\n", err)
}

channelConfigTxPath := filepath.Join(metadata.GetProjectPath(), metadata.ChannelConfigPath, channelConfigTxFile)
r, err := os.Open(channelConfigTxPath)
if err != nil {
    fmt.Printf("failed to open channel config: %s\n", err)
}
defer r.Close()

resp, err := c.SaveChannel(SaveChannelRequest{ChannelID: "mychannel", ChannelConfig: r}, WithOrdererEndpoint("example.com"))
if err != nil {
    fmt.Printf("failed to save channel: %s\n", err)
}

if resp.TransactionID == "" {
    fmt.Println("Failed to save channel")
}

fmt.Println("Saved channel")

Output:

Saved channel

func (*Client) UpgradeCC Uses

func (rc *Client) UpgradeCC(channelID string, req UpgradeCCRequest, options ...RequestOption) (UpgradeCCResponse, error)

UpgradeCC upgrades chaincode with optional custom options (specific peers, filtered peers, timeout). If peer(s) are not specified in options it will default to all channel peers.

Parameters:
channel is manadatory channel name
req holds info about mandatory chaincode name, path, version and policy
options holds optional request options

Returns:
upgrade chaincode response with transaction ID

Code:

c, err := New(mockClientProvider())
if err != nil {
    fmt.Println("failed to create client")
}

ccPolicy := policydsl.SignedByMspMember("Org1MSP")
req := UpgradeCCRequest{Name: "ExampleCC", Version: "v1", Path: "path", Policy: ccPolicy}

resp, err := c.UpgradeCC("mychannel", req, WithTargets(mockPeer()))
if err != nil {
    fmt.Printf("failed to upgrade chaincode: %s\n", err)
}

if resp.TransactionID == "" {
    fmt.Println("Failed to upgrade chaincode")
}

fmt.Println("Chaincode upgraded")

Output:

Chaincode upgraded

type ClientOption Uses

type ClientOption func(*Client) error

ClientOption describes a functional parameter for the New constructor

func WithDefaultTargetFilter Uses

func WithDefaultTargetFilter(filter fab.TargetFilter) ClientOption

WithDefaultTargetFilter option to configure default target filter per client

Code:

ctx := mockClientProvider()

c, err := New(ctx, WithDefaultTargetFilter(&urlTargetFilter{url: "example.com"}))
if err != nil {
    fmt.Println("failed to create client")
}

if c != nil {
    fmt.Println("resource management client created with url target filter")
}

Output:

resource management client created with url target filter

type InstallCCRequest Uses

type InstallCCRequest struct {
    Name    string
    Path    string
    Version string
    Package *resource.CCPackage
}

InstallCCRequest contains install chaincode request parameters

type InstallCCResponse Uses

type InstallCCResponse struct {
    Target string
    Status int32
    Info   string
}

InstallCCResponse contains install chaincode response status

type InstantiateCCRequest Uses

type InstantiateCCRequest struct {
    Name       string
    Path       string
    Version    string
    Lang       pb.ChaincodeSpec_Type
    Args       [][]byte
    Policy     *common.SignaturePolicyEnvelope
    CollConfig []*pb.CollectionConfig
}

InstantiateCCRequest contains instantiate chaincode request parameters

type InstantiateCCResponse Uses

type InstantiateCCResponse struct {
    TransactionID fab.TransactionID
}

InstantiateCCResponse contains response parameters for instantiate chaincode

type LifecycleApproveCCRequest Uses

type LifecycleApproveCCRequest struct {
    Name                string                          `json:"name,omitempty"`
    Version             string                          `json:"version,omitempty"`
    PackageID           string                          `json:"packageID,omitempty"`
    Sequence            int64                           `json:"sequence,omitempty"`
    EndorsementPlugin   string                          `json:"endorsementPlugin,omitempty"`
    ValidationPlugin    string                          `json:"validationPlugin,omitempty"`
    SignaturePolicy     *common.SignaturePolicyEnvelope `json:"signaturePolicy,omitempty"`
    ChannelConfigPolicy string                          `json:"channelConfigPolicy,omitempty"`
    CollectionConfig    []*pb.CollectionConfig          `json:"collectionConfig,omitempty"`
    InitRequired        bool                            `json:"initRequired,omitempty"`
}

LifecycleApproveCCRequest contains the parameters for approving a chaincode for an org.

type LifecycleApprovedChaincodeDefinition Uses

type LifecycleApprovedChaincodeDefinition struct {
    Name                string                          `json:"name,omitempty"`
    Version             string                          `json:"version,omitempty"`
    Sequence            int64                           `json:"sequence,omitempty"`
    EndorsementPlugin   string                          `json:"endorsementPlugin,omitempty"`
    ValidationPlugin    string                          `json:"validationPlugin,omitempty"`
    SignaturePolicy     *common.SignaturePolicyEnvelope `json:"signaturePolicy,omitempty"`
    ChannelConfigPolicy string                          `json:"channelConfigPolicy,omitempty"`
    CollectionConfig    []*pb.CollectionConfig          `json:"collectionConfig,omitempty"`
    InitRequired        bool                            `json:"initRequired,omitempty"`
    PackageID           string                          `json:"packageID,omitempty"`
}

LifecycleApprovedChaincodeDefinition contains information about the approved chaincode

type LifecycleChaincodeDefinition Uses

type LifecycleChaincodeDefinition struct {
    Name                string                          `json:"name,omitempty"`
    Version             string                          `json:"version,omitempty"`
    Sequence            int64                           `json:"sequence,omitempty"`
    EndorsementPlugin   string                          `json:"endorsementPlugin,omitempty"`
    ValidationPlugin    string                          `json:"validationPlugin,omitempty"`
    SignaturePolicy     *common.SignaturePolicyEnvelope `json:"signaturePolicy,omitempty"`
    ChannelConfigPolicy string                          `json:"channelConfigPolicy,omitempty"`
    CollectionConfig    []*pb.CollectionConfig          `json:"collectionConfig,omitempty"`
    InitRequired        bool                            `json:"initRequired,omitempty"`
    Approvals           map[string]bool                 `json:"approvals,omitempty"`
}

LifecycleChaincodeDefinition contains information about a committed chaincode. Note that approvals are only returned if a chaincode name is provided in the request.

type LifecycleCheckCCCommitReadinessRequest Uses

type LifecycleCheckCCCommitReadinessRequest struct {
    Name                string                          `json:"name,omitempty"`
    Version             string                          `json:"version,omitempty"`
    Sequence            int64                           `json:"sequence,omitempty"`
    EndorsementPlugin   string                          `json:"endorsementPlugin,omitempty"`
    ValidationPlugin    string                          `json:"validationPlugin,omitempty"`
    SignaturePolicy     *common.SignaturePolicyEnvelope `json:"signaturePolicy,omitempty"`
    ChannelConfigPolicy string                          `json:"channelConfigPolicy,omitempty"`
    CollectionConfig    []*pb.CollectionConfig          `json:"collectionConfig,omitempty"`
    InitRequired        bool                            `json:"initRequired,omitempty"`
}

LifecycleCheckCCCommitReadinessRequest contains the parameters for checking the 'commit readiness' of a chaincode

type LifecycleCheckCCCommitReadinessResponse Uses

type LifecycleCheckCCCommitReadinessResponse struct {
    Approvals map[string]bool `json:"approvals,omitempty"`
}

LifecycleCheckCCCommitReadinessResponse contains the org approvals for the chaincode

type LifecycleCommitCCRequest Uses

type LifecycleCommitCCRequest struct {
    Name                string                          `json:"name,omitempty"`
    Version             string                          `json:"version,omitempty"`
    Sequence            int64                           `json:"sequence,omitempty"`
    EndorsementPlugin   string                          `json:"endorsementPlugin,omitempty"`
    ValidationPlugin    string                          `json:"validationPlugin,omitempty"`
    SignaturePolicy     *common.SignaturePolicyEnvelope `json:"signaturePolicy,omitempty"`
    ChannelConfigPolicy string                          `json:"channelConfigPolicy,omitempty"`
    CollectionConfig    []*pb.CollectionConfig          `json:"collectionConfig,omitempty"`
    InitRequired        bool                            `json:"initRequired,omitempty"`
}

LifecycleCommitCCRequest contains the parameters for committing a chaincode

type LifecycleInstallCCRequest Uses

type LifecycleInstallCCRequest struct {
    Label   string `json:"label,omitempty"`
    Package []byte `json:"package,omitempty"`
}

LifecycleInstallCCRequest contains the parameters for installing chaincode

type LifecycleInstallCCResponse Uses

type LifecycleInstallCCResponse struct {
    Target    string `json:"target,omitempty"`
    Status    int32  `json:"status,omitempty"`
    PackageID string `json:"packageID,omitempty"`
}

LifecycleInstallCCResponse contains the response from a chaincode installation

type LifecycleInstalledCC Uses

type LifecycleInstalledCC struct {
    PackageID  string                   `json:"packageID,omitempty"`
    Label      string                   `json:"label,omitempty"`
    References map[string][]CCReference `json:"references,omitempty"`
}

LifecycleInstalledCC contains the package ID and label of the installed chaincode, including a map of channel name to chaincode name and version pairs of chaincode definitions that reference this chaincode package.

type LifecycleQueryApprovedCCRequest Uses

type LifecycleQueryApprovedCCRequest struct {
    Name     string `json:"name,omitempty"`
    Sequence int64  `json:"sequence,omitempty"`
}

LifecycleQueryApprovedCCRequest contains the parameters for querying approved chaincodes

type LifecycleQueryCommittedCCRequest Uses

type LifecycleQueryCommittedCCRequest struct {
    Name string `json:"name,omitempty"`
}

LifecycleQueryCommittedCCRequest contains the parameters to query committed chaincodes. If name is not provided then all committed chaincodes on the given channel are returned, otherwise only the chaincode with the given name is returned.

type MockChannelProvider Uses

type MockChannelProvider struct {
    ChannelServiceStub func(ctx fab.ClientContext, channelID string) (fab.ChannelService, error)
    // contains filtered or unexported fields
}

func (*MockChannelProvider) ChannelService Uses

func (fake *MockChannelProvider) ChannelService(ctx fab.ClientContext, channelID string) (fab.ChannelService, error)

func (*MockChannelProvider) ChannelServiceArgsForCall Uses

func (fake *MockChannelProvider) ChannelServiceArgsForCall(i int) (fab.ClientContext, string)

func (*MockChannelProvider) ChannelServiceCallCount Uses

func (fake *MockChannelProvider) ChannelServiceCallCount() int

func (*MockChannelProvider) ChannelServiceReturns Uses

func (fake *MockChannelProvider) ChannelServiceReturns(result1 fab.ChannelService, result2 error)

func (*MockChannelProvider) ChannelServiceReturnsOnCall Uses

func (fake *MockChannelProvider) ChannelServiceReturnsOnCall(i int, result1 fab.ChannelService, result2 error)

func (*MockChannelProvider) Invocations Uses

func (fake *MockChannelProvider) Invocations() map[string][][]interface{}

type MockChannelService Uses

type MockChannelService struct {
    ConfigStub func() (fab.ChannelConfig, error)

    EventServiceStub func(opts ...options.Opt) (fab.EventService, error)

    MembershipStub func() (fab.ChannelMembership, error)

    ChannelConfigStub func() (fab.ChannelCfg, error)

    TransactorStub func(reqCtx reqContext.Context) (fab.Transactor, error)

    DiscoveryStub func() (fab.DiscoveryService, error)

    SelectionStub func() (fab.SelectionService, error)
    // contains filtered or unexported fields
}

func (*MockChannelService) ChannelConfig Uses

func (fake *MockChannelService) ChannelConfig() (fab.ChannelCfg, error)

func (*MockChannelService) ChannelConfigCallCount Uses

func (fake *MockChannelService) ChannelConfigCallCount() int

func (*MockChannelService) ChannelConfigReturns Uses

func (fake *MockChannelService) ChannelConfigReturns(result1 fab.ChannelCfg, result2 error)

func (*MockChannelService) ChannelConfigReturnsOnCall Uses

func (fake *MockChannelService) ChannelConfigReturnsOnCall(i int, result1 fab.ChannelCfg, result2 error)

func (*MockChannelService) Config Uses

func (fake *MockChannelService) Config() (fab.ChannelConfig, error)

func (*MockChannelService) ConfigCallCount Uses

func (fake *MockChannelService) ConfigCallCount() int

func (*MockChannelService) ConfigReturns Uses

func (fake *MockChannelService) ConfigReturns(result1 fab.ChannelConfig, result2 error)

func (*MockChannelService) ConfigReturnsOnCall Uses

func (fake *MockChannelService) ConfigReturnsOnCall(i int, result1 fab.ChannelConfig, result2 error)

func (*MockChannelService) Discovery Uses

func (fake *MockChannelService) Discovery() (fab.DiscoveryService, error)

func (*MockChannelService) DiscoveryCallCount Uses

func (fake *MockChannelService) DiscoveryCallCount() int

func (*MockChannelService) DiscoveryReturns Uses

func (fake *MockChannelService) DiscoveryReturns(result1 fab.DiscoveryService, result2 error)

func (*MockChannelService) DiscoveryReturnsOnCall Uses

func (fake *MockChannelService) DiscoveryReturnsOnCall(i int, result1 fab.DiscoveryService, result2 error)

func (*MockChannelService) EventService Uses

func (fake *MockChannelService) EventService(opts ...options.Opt) (fab.EventService, error)

func (*MockChannelService) EventServiceArgsForCall Uses

func (fake *MockChannelService) EventServiceArgsForCall(i int) []options.Opt

func (*MockChannelService) EventServiceCallCount Uses

func (fake *MockChannelService) EventServiceCallCount() int

func (*MockChannelService) EventServiceReturns Uses

func (fake *MockChannelService) EventServiceReturns(result1 fab.EventService, result2 error)

func (*MockChannelService) EventServiceReturnsOnCall Uses

func (fake *MockChannelService) EventServiceReturnsOnCall(i int, result1 fab.EventService, result2 error)

func (*MockChannelService) Invocations Uses

func (fake *MockChannelService) Invocations() map[string][][]interface{}

func (*MockChannelService) Membership Uses

func (fake *MockChannelService) Membership() (fab.ChannelMembership, error)

func (*MockChannelService) MembershipCallCount Uses

func (fake *MockChannelService) MembershipCallCount() int

func (*MockChannelService) MembershipReturns Uses

func (fake *MockChannelService) MembershipReturns(result1 fab.ChannelMembership, result2 error)

func (*MockChannelService) MembershipReturnsOnCall Uses

func (fake *MockChannelService) MembershipReturnsOnCall(i int, result1 fab.ChannelMembership, result2 error)

func (*MockChannelService) Selection Uses

func (fake *MockChannelService) Selection() (fab.SelectionService, error)

func (*MockChannelService) SelectionCallCount Uses

func (fake *MockChannelService) SelectionCallCount() int

func (*MockChannelService) SelectionReturns Uses

func (fake *MockChannelService) SelectionReturns(result1 fab.SelectionService, result2 error)

func (*MockChannelService) SelectionReturnsOnCall Uses

func (fake *MockChannelService) SelectionReturnsOnCall(i int, result1 fab.SelectionService, result2 error)

func (*MockChannelService) Transactor Uses

func (fake *MockChannelService) Transactor(reqCtx reqContext.Context) (fab.Transactor, error)

func (*MockChannelService) TransactorArgsForCall Uses

func (fake *MockChannelService) TransactorArgsForCall(i int) reqContext.Context

func (*MockChannelService) TransactorCallCount Uses

func (fake *MockChannelService) TransactorCallCount() int

func (*MockChannelService) TransactorReturns Uses

func (fake *MockChannelService) TransactorReturns(result1 fab.Transactor, result2 error)

func (*MockChannelService) TransactorReturnsOnCall Uses

func (fake *MockChannelService) TransactorReturnsOnCall(i int, result1 fab.Transactor, result2 error)

type MockLifecycleResource Uses

type MockLifecycleResource struct {
    InstallStub func(reqCtx reqContext.Context, installPkg []byte, targets []fab.ProposalProcessor, opts ...resource.Opt) ([]*resource.LifecycleInstallProposalResponse, error)

    GetInstalledPackageStub func(reqCtx reqContext.Context, packageID string, target fab.ProposalProcessor, opts ...resource.Opt) ([]byte, error)

    QueryInstalledStub func(reqCtx reqContext.Context, target fab.ProposalProcessor, opts ...resource.Opt) (*resource.LifecycleQueryInstalledCCResponse, error)

    QueryApprovedStub func(reqCtx reqContext.Context, channelID string, req *resource.QueryApprovedChaincodeRequest, target fab.ProposalProcessor, opts ...resource.Opt) (*resource.LifecycleQueryApprovedCCResponse, error)

    CreateApproveProposalStub func(txh fab.TransactionHeader, req *resource.ApproveChaincodeRequest) (*fab.TransactionProposal, error)

    CreateCheckCommitReadinessProposalStub func(txh fab.TransactionHeader, req *resource.CheckChaincodeCommitReadinessRequest) (*fab.TransactionProposal, error)

    CreateCommitProposalStub func(txh fab.TransactionHeader, req *resource.CommitChaincodeRequest) (*fab.TransactionProposal, error)

    CreateQueryCommittedProposalStub func(txh fab.TransactionHeader, req *resource.QueryCommittedChaincodesRequest) (*fab.TransactionProposal, error)

    UnmarshalApplicationPolicyStub func(policyBytes []byte) (*common.SignaturePolicyEnvelope, string, error)
    // contains filtered or unexported fields
}

func (*MockLifecycleResource) CreateApproveProposal Uses

func (fake *MockLifecycleResource) CreateApproveProposal(txh fab.TransactionHeader, req *resource.ApproveChaincodeRequest) (*fab.TransactionProposal, error)

func (*MockLifecycleResource) CreateApproveProposalArgsForCall Uses

func (fake *MockLifecycleResource) CreateApproveProposalArgsForCall(i int) (fab.TransactionHeader, *resource.ApproveChaincodeRequest)

func (*MockLifecycleResource) CreateApproveProposalCallCount Uses

func (fake *MockLifecycleResource) CreateApproveProposalCallCount() int

func (*MockLifecycleResource) CreateApproveProposalReturns Uses

func (fake *MockLifecycleResource) CreateApproveProposalReturns(result1 *fab.TransactionProposal, result2 error)

func (*MockLifecycleResource) CreateApproveProposalReturnsOnCall Uses

func (fake *MockLifecycleResource) CreateApproveProposalReturnsOnCall(i int, result1 *fab.TransactionProposal, result2 error)

func (*MockLifecycleResource) CreateCheckCommitReadinessProposal Uses

func (fake *MockLifecycleResource) CreateCheckCommitReadinessProposal(txh fab.TransactionHeader, req *resource.CheckChaincodeCommitReadinessRequest) (*fab.TransactionProposal, error)

func (*MockLifecycleResource) CreateCheckCommitReadinessProposalArgsForCall Uses

func (fake *MockLifecycleResource) CreateCheckCommitReadinessProposalArgsForCall(i int) (fab.TransactionHeader, *resource.CheckChaincodeCommitReadinessRequest)

func (*MockLifecycleResource) CreateCheckCommitReadinessProposalCallCount Uses

func (fake *MockLifecycleResource) CreateCheckCommitReadinessProposalCallCount() int

func (*MockLifecycleResource) CreateCheckCommitReadinessProposalReturns Uses

func (fake *MockLifecycleResource) CreateCheckCommitReadinessProposalReturns(result1 *fab.TransactionProposal, result2 error)

func (*MockLifecycleResource) CreateCheckCommitReadinessProposalReturnsOnCall Uses

func (fake *MockLifecycleResource) CreateCheckCommitReadinessProposalReturnsOnCall(i int, result1 *fab.TransactionProposal, result2 error)

func (*MockLifecycleResource) CreateCommitProposal Uses

func (fake *MockLifecycleResource) CreateCommitProposal(txh fab.TransactionHeader, req *resource.CommitChaincodeRequest) (*fab.TransactionProposal, error)

func (*MockLifecycleResource) CreateCommitProposalArgsForCall Uses

func (fake *MockLifecycleResource) CreateCommitProposalArgsForCall(i int) (fab.TransactionHeader, *resource.CommitChaincodeRequest)

func (*MockLifecycleResource) CreateCommitProposalCallCount Uses

func (fake *MockLifecycleResource) CreateCommitProposalCallCount() int

func (*MockLifecycleResource) CreateCommitProposalReturns Uses

func (fake *MockLifecycleResource) CreateCommitProposalReturns(result1 *fab.TransactionProposal, result2 error)

func (*MockLifecycleResource) CreateCommitProposalReturnsOnCall Uses

func (fake *MockLifecycleResource) CreateCommitProposalReturnsOnCall(i int, result1 *fab.TransactionProposal, result2 error)

func (*MockLifecycleResource) CreateQueryCommittedProposal Uses

func (fake *MockLifecycleResource) CreateQueryCommittedProposal(txh fab.TransactionHeader, req *resource.QueryCommittedChaincodesRequest) (*fab.TransactionProposal, error)

func (*MockLifecycleResource) CreateQueryCommittedProposalArgsForCall Uses

func (fake *MockLifecycleResource) CreateQueryCommittedProposalArgsForCall(i int) (fab.TransactionHeader, *resource.QueryCommittedChaincodesRequest)

func (*MockLifecycleResource) CreateQueryCommittedProposalCallCount Uses

func (fake *MockLifecycleResource) CreateQueryCommittedProposalCallCount() int

func (*MockLifecycleResource) CreateQueryCommittedProposalReturns Uses

func (fake *MockLifecycleResource) CreateQueryCommittedProposalReturns(result1 *fab.TransactionProposal, result2 error)

func (*MockLifecycleResource) CreateQueryCommittedProposalReturnsOnCall Uses

func (fake *MockLifecycleResource) CreateQueryCommittedProposalReturnsOnCall(i int, result1 *fab.TransactionProposal, result2 error)

func (*MockLifecycleResource) GetInstalledPackage Uses

func (fake *MockLifecycleResource) GetInstalledPackage(reqCtx reqContext.Context, packageID string, target fab.ProposalProcessor, opts ...resource.Opt) ([]byte, error)

func (*MockLifecycleResource) GetInstalledPackageArgsForCall Uses

func (fake *MockLifecycleResource) GetInstalledPackageArgsForCall(i int) (reqContext.Context, string, fab.ProposalProcessor, []resource.Opt)

func (*MockLifecycleResource) GetInstalledPackageCallCount Uses

func (fake *MockLifecycleResource) GetInstalledPackageCallCount() int

func (*MockLifecycleResource) GetInstalledPackageReturns Uses

func (fake *MockLifecycleResource) GetInstalledPackageReturns(result1 []byte, result2 error)

func (*MockLifecycleResource) GetInstalledPackageReturnsOnCall Uses

func (fake *MockLifecycleResource) GetInstalledPackageReturnsOnCall(i int, result1 []byte, result2 error)

func (*MockLifecycleResource) Install Uses

func (fake *MockLifecycleResource) Install(reqCtx reqContext.Context, installPkg []byte, targets []fab.ProposalProcessor, opts ...resource.Opt) ([]*resource.LifecycleInstallProposalResponse, error)

func (*MockLifecycleResource) InstallArgsForCall Uses

func (fake *MockLifecycleResource) InstallArgsForCall(i int) (reqContext.Context, []byte, []fab.ProposalProcessor, []resource.Opt)

func (*MockLifecycleResource) InstallCallCount Uses

func (fake *MockLifecycleResource) InstallCallCount() int

func (*MockLifecycleResource) InstallReturns Uses

func (fake *MockLifecycleResource) InstallReturns(result1 []*resource.LifecycleInstallProposalResponse, result2 error)

func (*MockLifecycleResource) InstallReturnsOnCall Uses

func (fake *MockLifecycleResource) InstallReturnsOnCall(i int, result1 []*resource.LifecycleInstallProposalResponse, result2 error)

func (*MockLifecycleResource) Invocations Uses

func (fake *MockLifecycleResource) Invocations() map[string][][]interface{}

func (*MockLifecycleResource) QueryApproved Uses

func (fake *MockLifecycleResource) QueryApproved(reqCtx reqContext.Context, channelID string, req *resource.QueryApprovedChaincodeRequest, target fab.ProposalProcessor, opts ...resource.Opt) (*resource.LifecycleQueryApprovedCCResponse, error)

func (*MockLifecycleResource) QueryApprovedArgsForCall Uses

func (fake *MockLifecycleResource) QueryApprovedArgsForCall(i int) (reqContext.Context, string, *resource.QueryApprovedChaincodeRequest, fab.ProposalProcessor, []resource.Opt)

func (*MockLifecycleResource) QueryApprovedCallCount Uses

func (fake *MockLifecycleResource) QueryApprovedCallCount() int

func (*MockLifecycleResource) QueryApprovedReturns Uses

func (fake *MockLifecycleResource) QueryApprovedReturns(result1 *resource.LifecycleQueryApprovedCCResponse, result2 error)

func (*MockLifecycleResource) QueryApprovedReturnsOnCall Uses

func (fake *MockLifecycleResource) QueryApprovedReturnsOnCall(i int, result1 *resource.LifecycleQueryApprovedCCResponse, result2 error)

func (*MockLifecycleResource) QueryInstalled Uses

func (fake *MockLifecycleResource) QueryInstalled(reqCtx reqContext.Context, target fab.ProposalProcessor, opts ...resource.Opt) (*resource.LifecycleQueryInstalledCCResponse, error)

func (*MockLifecycleResource) QueryInstalledArgsForCall Uses

func (fake *MockLifecycleResource) QueryInstalledArgsForCall(i int) (reqContext.Context, fab.ProposalProcessor, []resource.Opt)

func (*MockLifecycleResource) QueryInstalledCallCount Uses

func (fake *MockLifecycleResource) QueryInstalledCallCount() int

func (*MockLifecycleResource) QueryInstalledReturns Uses

func (fake *MockLifecycleResource) QueryInstalledReturns(result1 *resource.LifecycleQueryInstalledCCResponse, result2 error)

func (*MockLifecycleResource) QueryInstalledReturnsOnCall Uses

func (fake *MockLifecycleResource) QueryInstalledReturnsOnCall(i int, result1 *resource.LifecycleQueryInstalledCCResponse, result2 error)

func (*MockLifecycleResource) UnmarshalApplicationPolicy Uses

func (fake *MockLifecycleResource) UnmarshalApplicationPolicy(policyBytes []byte) (*common.SignaturePolicyEnvelope, string, error)

func (*MockLifecycleResource) UnmarshalApplicationPolicyArgsForCall Uses

func (fake *MockLifecycleResource) UnmarshalApplicationPolicyArgsForCall(i int) []byte

func (*MockLifecycleResource) UnmarshalApplicationPolicyCallCount Uses

func (fake *MockLifecycleResource) UnmarshalApplicationPolicyCallCount() int

func (*MockLifecycleResource) UnmarshalApplicationPolicyReturns Uses

func (fake *MockLifecycleResource) UnmarshalApplicationPolicyReturns(result1 *common.SignaturePolicyEnvelope, result2 string, result3 error)

func (*MockLifecycleResource) UnmarshalApplicationPolicyReturnsOnCall Uses

func (fake *MockLifecycleResource) UnmarshalApplicationPolicyReturnsOnCall(i int, result1 *common.SignaturePolicyEnvelope, result2 string, result3 error)

type MockTransactor Uses

type MockTransactor struct {
    CreateTransactionStub func(request fab.TransactionRequest) (*fab.Transaction, error)

    SendTransactionStub func(tx *fab.Transaction) (*fab.TransactionResponse, error)

    CreateTransactionHeaderStub func(opts ...fab.TxnHeaderOpt) (fab.TransactionHeader, error)

    SendTransactionProposalStub func(*fab.TransactionProposal, []fab.ProposalProcessor) ([]*fab.TransactionProposalResponse, error)
    // contains filtered or unexported fields
}

func (*MockTransactor) CreateTransaction Uses

func (fake *MockTransactor) CreateTransaction(request fab.TransactionRequest) (*fab.Transaction, error)

func (*MockTransactor) CreateTransactionArgsForCall Uses

func (fake *MockTransactor) CreateTransactionArgsForCall(i int) fab.TransactionRequest

func (*MockTransactor) CreateTransactionCallCount Uses

func (fake *MockTransactor) CreateTransactionCallCount() int

func (*MockTransactor) CreateTransactionHeader Uses

func (fake *MockTransactor) CreateTransactionHeader(opts ...fab.TxnHeaderOpt) (fab.TransactionHeader, error)

func (*MockTransactor) CreateTransactionHeaderArgsForCall Uses

func (fake *MockTransactor) CreateTransactionHeaderArgsForCall(i int) []fab.TxnHeaderOpt

func (*MockTransactor) CreateTransactionHeaderCallCount Uses

func (fake *MockTransactor) CreateTransactionHeaderCallCount() int

func (*MockTransactor) CreateTransactionHeaderReturns Uses

func (fake *MockTransactor) CreateTransactionHeaderReturns(result1 fab.TransactionHeader, result2 error)

func (*MockTransactor) CreateTransactionHeaderReturnsOnCall Uses

func (fake *MockTransactor) CreateTransactionHeaderReturnsOnCall(i int, result1 fab.TransactionHeader, result2 error)

func (*MockTransactor) CreateTransactionReturns Uses

func (fake *MockTransactor) CreateTransactionReturns(result1 *fab.Transaction, result2 error)

func (*MockTransactor) CreateTransactionReturnsOnCall Uses

func (fake *MockTransactor) CreateTransactionReturnsOnCall(i int, result1 *fab.Transaction, result2 error)

func (*MockTransactor) Invocations Uses

func (fake *MockTransactor) Invocations() map[string][][]interface{}

func (*MockTransactor) SendTransaction Uses

func (fake *MockTransactor) SendTransaction(tx *fab.Transaction) (*fab.TransactionResponse, error)

func (*MockTransactor) SendTransactionArgsForCall Uses

func (fake *MockTransactor) SendTransactionArgsForCall(i int) *fab.Transaction

func (*MockTransactor) SendTransactionCallCount Uses

func (fake *MockTransactor) SendTransactionCallCount() int

func (*MockTransactor) SendTransactionProposal Uses

func (fake *MockTransactor) SendTransactionProposal(arg1 *fab.TransactionProposal, arg2 []fab.ProposalProcessor) ([]*fab.TransactionProposalResponse, error)

func (*MockTransactor) SendTransactionProposalArgsForCall Uses

func (fake *MockTransactor) SendTransactionProposalArgsForCall(i int) (*fab.TransactionProposal, []fab.ProposalProcessor)

func (*MockTransactor) SendTransactionProposalCallCount Uses

func (fake *MockTransactor) SendTransactionProposalCallCount() int

func (*MockTransactor) SendTransactionProposalReturns Uses

func (fake *MockTransactor) SendTransactionProposalReturns(result1 []*fab.TransactionProposalResponse, result2 error)

func (*MockTransactor) SendTransactionProposalReturnsOnCall Uses

func (fake *MockTransactor) SendTransactionProposalReturnsOnCall(i int, result1 []*fab.TransactionProposalResponse, result2 error)

func (*MockTransactor) SendTransactionReturns Uses

func (fake *MockTransactor) SendTransactionReturns(result1 *fab.TransactionResponse, result2 error)

func (*MockTransactor) SendTransactionReturnsOnCall Uses

func (fake *MockTransactor) SendTransactionReturnsOnCall(i int, result1 *fab.TransactionResponse, result2 error)

type RequestOption Uses

type RequestOption func(ctx context.Client, opts *requestOptions) error

RequestOption func for each Opts argument

func WithConfigSignatures Uses

func WithConfigSignatures(signatures ...*common.ConfigSignature) RequestOption

WithConfigSignatures allows to provide pre defined signatures for resmgmt client's SaveChannel call

func WithOrderer Uses

func WithOrderer(orderer fab.Orderer) RequestOption

WithOrderer allows an orderer to be specified for the request.

func WithOrdererEndpoint Uses

func WithOrdererEndpoint(key string) RequestOption

WithOrdererEndpoint allows an orderer to be specified for the request. The orderer will be looked-up based on the key argument. key argument can be a name or url

func WithParentContext Uses

func WithParentContext(parentContext reqContext.Context) RequestOption

WithParentContext encapsulates grpc parent context.

Code:

c, err := New(mockClientProvider())
if err != nil {
    fmt.Println("failed to create client")
}

clientContext, err := mockClientProvider()()
if err != nil {
    fmt.Println("failed to return client context")
    return
}

// get parent context and cancel
parentContext, cancel := sdkCtx.NewRequest(clientContext, sdkCtx.WithTimeout(20*time.Second))
defer cancel()

channels, err := c.QueryChannels(WithParentContext(parentContext), WithTargets(mockPeer()))
if err != nil {
    fmt.Printf("failed to query for blockchain info: %s\n", err)
}

if channels != nil {
    fmt.Println("Retrieved channels that peer belongs to")
}

Output:

Retrieved channels that peer belongs to

func WithRetry Uses

func WithRetry(retryOpt retry.Opts) RequestOption

WithRetry sets retry options.

func WithTargetEndpoints Uses

func WithTargetEndpoints(keys ...string) RequestOption

WithTargetEndpoints allows overriding of the target peers for the request. Targets are specified by name or URL, and the SDK will create the underlying peer objects.

func WithTargetFilter Uses

func WithTargetFilter(targetFilter fab.TargetFilter) RequestOption

WithTargetFilter enables a target filter for the request.

Code:

c, err := New(mockClientProvider())
if err != nil {
    fmt.Println("failed to create client")
}

ccPolicy := policydsl.SignedByMspMember("Org1MSP")
req := InstantiateCCRequest{Name: "ExampleCC", Version: "v0", Path: "path", Policy: ccPolicy}

resp, err := c.InstantiateCC("mychannel", req, WithTargetFilter(&urlTargetFilter{url: "http://peer1.com"}))
if err != nil {
    fmt.Printf("failed to install chaincode: %s\n", err)
}

if resp.TransactionID == "" {
    fmt.Println("Failed to instantiate chaincode")
}

fmt.Println("Chaincode instantiated")

Output:

Chaincode instantiated

func WithTargets Uses

func WithTargets(targets ...fab.Peer) RequestOption

WithTargets allows overriding of the target peers for the request.

Code:

c, err := New(mockClientProvider())
if err != nil {
    fmt.Println("failed to create client")
}

response, err := c.QueryChannels(WithTargets(mockPeer()))
if err != nil {
    fmt.Printf("failed to query channels: %s\n", err)
}

if response != nil {
    fmt.Println("Retrieved channels")
}

Output:

Retrieved channels

func WithTimeout Uses

func WithTimeout(timeoutType fab.TimeoutType, timeout time.Duration) RequestOption

WithTimeout encapsulates key value pairs of timeout type, timeout duration to Options if not provided, default timeout configuration from config will be used

type SaveChannelRequest Uses

type SaveChannelRequest struct {
    ChannelID         string
    ChannelConfig     io.Reader // ChannelConfig data source
    ChannelConfigPath string    // Convenience option to use the named file as ChannelConfig reader
    // Users that sign channel configuration
    // deprecated - one entity shouldn't have access to another entities' keys to sign on their behalf
    SigningIdentities []msp.SigningIdentity
}

SaveChannelRequest holds parameters for save channel request

type SaveChannelResponse Uses

type SaveChannelResponse struct {
    TransactionID fab.TransactionID
}

SaveChannelResponse contains response parameters for save channel

type UpgradeCCRequest Uses

type UpgradeCCRequest struct {
    Name       string
    Path       string
    Version    string
    Lang       pb.ChaincodeSpec_Type
    Args       [][]byte
    Policy     *common.SignaturePolicyEnvelope
    CollConfig []*pb.CollectionConfig
}

UpgradeCCRequest contains upgrade chaincode request parameters

type UpgradeCCResponse Uses

type UpgradeCCResponse struct {
    TransactionID fab.TransactionID
}

UpgradeCCResponse contains response parameters for upgrade chaincode

Package resmgmt imports 33 packages (graph) and is imported by 10 packages. Updated 2020-11-04. Refresh now. Tools for package owners.