config

Documentation

Index

• Constants
• type CCP
  • func GenerateEmptyCcp(ccpName string, ccpVersion string, orgName string, endorser uint) *CCP
  • func (that *CCP) AddCa(peerName string, orgName string, domainRoot string, gRpcPort uint, ...)
  • func (that *CCP) AddPeer(peerName string, orgName string, domainRoot string, gRpcPort uint, ...)
  • func (that *CCP) ExportJson(path string) error
  • func (that *CCP) ExportYaml(path string) error
• type CcpCaHttpOptions
• type CcpCaTlsCaCert
• type CcpCertificateAuthorities
• type CcpClient
• type CcpClientConnection
• type CcpClientConnectionPeer
• type CcpClientConnectionPeerEndorser
• type CcpOrganization
• type CcpPeer
• type CcpPeerGrpcOptions
• type CcpPeerTlsCACerts
• type OrdererCryptoConfig
  • func GenerateDefaultOrdererCryptoConfig(name, domainRoot string) *OrdererCryptoConfig
• type OrdererCryptoConfigSpecs
• type PeerCryptoConfig
  • func GenerateDefaultPeerCryptoConfig(orgName, domainRoot string, count, users uint) *PeerCryptoConfig
• type PeerCryptoConfigTemplate
• type PeerCryptoConfigUsers

Constants

const Arch = "amd64"

const AssertsPath = FaberRootPath + "asserts/"

const BasePath = "/root/"

const BinaryPath = FaberRootPath + "bin/"

const ConfigPath = FaberRootPath + "config/"

const DockerPath = FaberRootPath + "docker/"

const EnvironmentFilePath = "/etc/profile.d/faber.sh"

const FaberRootPath = "faber/"

const FabricCaVersion = "1.4"

const FabricCaVersionFull = "1.4.8"

const FabricDataPath = FaberRootPath + "data/"

const FabricVersion = "2.2"

const FabricVersionFull = "2.2.0"

const Go = FaberRootPath + "go/"

const GoDownloadPath = "https://go.dev/dl/"

const GoPath = BasePath + "go/"

const GoVersion = "1.19"

const LocalDataPath = "./config/hyperledger/data/"

const LocalDockerPath = LocalDataPath + "docker/"

const LogPath = FaberRootPath + "log/"

const OS = "linux"

Types

type CCP

type CCP struct {
	Name                   string                                `json:"name" yaml:"name"`
	Version                string                                `json:"version" yaml:"version"`
	Client                 *CcpClient                            `json:"client" yaml:"client"`
	Organizations          map[string]*CcpOrganization           `json:"organizations" yaml:"organizations"`
	Peers                  map[string]*CcpPeer                   `json:"peers" yaml:"peers"`
	CertificateAuthorities map[string]*CcpCertificateAuthorities `json:"certificateAuthorities" yaml:"certificateAuthorities"`
}

func GenerateEmptyCcp

func GenerateEmptyCcp(ccpName string, ccpVersion string, orgName string, endorser uint) *CCP

func (*CCP) AddCa

func (that *CCP) AddCa(peerName string, orgName string, domainRoot string, gRpcPort uint, caPemPath string, verifyHttp bool)

func (*CCP) AddPeer

func (that *CCP) AddPeer(peerName string, orgName string, domainRoot string, gRpcPort uint, peerPemPath string)

func (*CCP) ExportJson

func (that *CCP) ExportJson(path string) error

func (*CCP) ExportYaml

func (that *CCP) ExportYaml(path string) error

type CcpCaHttpOptions

type CcpCaHttpOptions struct {
	Verify bool `json:"verify" yaml:"verify"`
}

type CcpCaTlsCaCert

type CcpCaTlsCaCert struct {
	Pem []string `json:"pem" yaml:"pem"`
}

type CcpCertificateAuthorities

type CcpCertificateAuthorities struct {
	Url         string            `json:"url" yaml:"url"`
	CaName      string            `json:"caName" yaml:"caName"`
	TlsCaCerts  *CcpCaTlsCaCert   `json:"tlsCaCerts" yaml:"tlsCaCerts"`
	HttpOptions *CcpCaHttpOptions `json:"httpOptions" yaml:"httpOptions"`
}

type CcpClient

type CcpClient struct {
	Organization string               `json:"organization" yaml:"organization"`
	Connection   *CcpClientConnection `json:"connection" yaml:"connection"`
}

type CcpClientConnection

type CcpClientConnection struct {
	Timeout *CcpClientConnectionPeer `json:"timeout" yaml:"timeout"`
}

type CcpClientConnectionPeer

type CcpClientConnectionPeer struct {
	Peer *CcpClientConnectionPeerEndorser `json:"peer" yaml:"peer"`
}

type CcpClientConnectionPeerEndorser

type CcpClientConnectionPeerEndorser struct {
	Endorser string `json:"endorser" yaml:"endorser"`
}

type CcpOrganization

type CcpOrganization struct {
	MspId                  string   `json:"mspid" yaml:"mspid"`
	Peers                  []string `json:"peers" yaml:"peers"`
	CertificateAuthorities []string `json:"certificateAuthorities" yaml:"certificateAuthorities"`
}

type CcpPeer

type CcpPeer struct {
	Url         string              `json:"url" yaml:"url"` // grpc
	TlsCACerts  *CcpPeerTlsCACerts  `json:"tlsCaCerts" yaml:"tlsCACerts"`
	GrpcOptions *CcpPeerGrpcOptions `json:"grpcOptions" yaml:"grpcOptions"`
}

type CcpPeerGrpcOptions

type CcpPeerGrpcOptions struct {
	SslTargetNameOverride string `json:"ssl-target-name-override" yaml:"ssl-target-name-override"`
	HostnameOverride      string `json:"hostnameOverride" yaml:"hostname-override"`
}

type CcpPeerTlsCACerts

type CcpPeerTlsCACerts struct {
	Pem string `json:"pem" yaml:"pem"`
}

type OrdererCryptoConfig

type OrdererCryptoConfig struct {
	Name          string                      `yaml:"Name"`
	Domain        string                      `yaml:"Domain"`
	EnableNodeOUs bool                        `yaml:"EnableNodeOUs"`
	Specs         []*OrdererCryptoConfigSpecs `yaml:"Specs"`
}

func GenerateDefaultOrdererCryptoConfig

func GenerateDefaultOrdererCryptoConfig(name, domainRoot string) *OrdererCryptoConfig

type OrdererCryptoConfigSpecs

type OrdererCryptoConfigSpecs struct {
	Hostname string   `yaml:"Hostname"`
	SANS     []string `yaml:"SANS"`
}

type PeerCryptoConfig

type PeerCryptoConfig struct {
	Name          string                    `yaml:"Name"`
	Domain        string                    `yaml:"Domain"`
	EnableNodeOUs bool                      `yaml:"EnableNodeOUs"`
	Template      *PeerCryptoConfigTemplate `yaml:"Template"`
	Users         *PeerCryptoConfigUsers    `yaml:"Users"`
}

func GenerateDefaultPeerCryptoConfig

func GenerateDefaultPeerCryptoConfig(orgName, domainRoot string, count, users uint) *PeerCryptoConfig

type PeerCryptoConfigTemplate

type PeerCryptoConfigTemplate struct {
	Count uint     `yaml:"Count"`
	SANS  []string `yaml:"SANS"`
}

type PeerCryptoConfigUsers

type PeerCryptoConfigUsers struct {
	Count uint `yaml:"Count"`
}