func TestLoggingLevelForUnknownCommandGoesToDefault(t *testing.T) {
viper.Reset()
flogging.LoggingInit("unknown command")
assertDefaultLoggingLevel(t, flogging.DefaultLoggingLevel())
}
func TestLoggingLevelDefault(t *testing.T) {
viper.Reset()
flogging.LoggingInit("")
assertDefaultLoggingLevel(t, flogging.DefaultLoggingLevel())
}
func TestLoggingLevelForSpecificModule(t *testing.T) {
viper.Reset()
viper.Set("logging_level", "core=info")
flogging.LoggingInit("")
assertModuleLoggingLevel(t, "core", logging.INFO)
}
func TestLoggingLevelOtherThanDefault(t *testing.T) {
viper.Reset()
viper.Set("logging_level", "warning")
flogging.LoggingInit("")
assertDefaultLoggingLevel(t, logging.WARNING)
}
func TestLoggingLevelInvalidEmptyModule(t *testing.T) {
viper.Reset()
viper.Set("logging_level", "=warning")
flogging.LoggingInit("")
assertDefaultLoggingLevel(t, flogging.DefaultLoggingLevel())
}
func TestLoggingLevelInvalidModules(t *testing.T) {
viper.Reset()
viper.Set("logging_level", "core=invalid")
flogging.LoggingInit("")
assertDefaultLoggingLevel(t, flogging.DefaultLoggingLevel())
}
func TestLoggingLevelForSpecificCommand(t *testing.T) {
viper.Reset()
viper.Set("logging.node", "error")
flogging.LoggingInit("node")
assertDefaultLoggingLevel(t, logging.ERROR)
}
func TestLoggingLevelInvalidModuleSyntax(t *testing.T) {
viper.Reset()
viper.Set("logging_level", "type=warn=again")
flogging.LoggingInit("")
assertDefaultLoggingLevel(t, flogging.DefaultLoggingLevel())
}
func TestLoggingLevelForModuleWithDefaultAtEnd(t *testing.T) {
viper.Reset()
viper.Set("logging_level", "test=warning:info")
flogging.LoggingInit("")
assertDefaultLoggingLevel(t, logging.INFO)
assertModuleLoggingLevel(t, "test", logging.WARNING)
}
func TestLoggingLevelForMultipleModulesAtSameLevel(t *testing.T) {
viper.Reset()
viper.Set("logging_level", "core,test=warning")
flogging.LoggingInit("")
assertModuleLoggingLevel(t, "core", logging.WARNING)
assertModuleLoggingLevel(t, "test", logging.WARNING)
}
func TestLoggingLeveltForMultipleModules(t *testing.T) {
viper.Reset()
viper.Set("logging_level", "core=warning:test=debug")
flogging.LoggingInit("")
assertModuleLoggingLevel(t, "core", logging.WARNING)
assertModuleLoggingLevel(t, "test", logging.DEBUG)
}
// NewCA sets up a new CA.
func NewCA(name string, initTables TableInitializer) *CA {
ca := new(CA)
flogging.LoggingInit("ca")
ca.path = filepath.Join(rootPath, caDir)
if _, err := os.Stat(ca.path); err != nil {
caLogger.Info("Fresh start; creating databases, key pairs, and certificates.")
if err := os.MkdirAll(ca.path, 0755); err != nil {
caLogger.Panic(err)
}
}
// open or create certificate database
db, err := sql.Open("sqlite3", ca.path+"/"+name+".db")
if err != nil {
caLogger.Panic(err)
}
if err = db.Ping(); err != nil {
caLogger.Panic(err)
}
if err = initTables(db); err != nil {
caLogger.Panic(err)
}
ca.db = db
// read or create signing key pair
priv, err := ca.readCAPrivateKey(name)
if err != nil {
priv = ca.createCAKeyPair(name)
}
ca.priv = priv
// read CA certificate, or create a self-signed CA certificate
raw, err := ca.readCACertificate(name)
if err != nil {
raw = ca.createCACertificate(name, &ca.priv.PublicKey)
}
cert, err := x509.ParseCertificate(raw)
if err != nil {
caLogger.Panic(err)
}
ca.raw = raw
ca.cert = cert
return ca
}
// NewTCA sets up a new TCA.
func NewTCA(eca *ECA) *TCA {
tca := &TCA{NewCA("tca", initializeTCATables), eca, nil, nil, nil, nil}
flogging.LoggingInit("tca")
err := tca.readHmacKey()
if err != nil {
tcaLogger.Panic(err)
}
err = tca.readRootPreKey()
if err != nil {
tcaLogger.Panic(err)
}
err = tca.initializePreKeyTree()
if err != nil {
tcaLogger.Panic(err)
}
return tca
}
// NewACA sets up a new ACA.
func NewACA() *ACA {
aca := &ACA{CA: NewCA("aca", initializeACATables)}
flogging.LoggingInit("aca")
return aca
}
// NewTLSCA sets up a new TLSCA.
//
func NewTLSCA(eca *ECA) *TLSCA {
tlsca := &TLSCA{NewCA("tlsca", initializeTLSCATables), eca, nil}
flogging.LoggingInit("tlsca")
return tlsca
}
"github.com/hyperledger/fabric/peer/node"
"github.com/hyperledger/fabric/peer/version"
)
var logger = logging.MustGetLogger("main")
// Constants go here.
const cmdRoot = "core"
// The main command describes the service and
// defaults to printing the help message.
var mainCmd = &cobra.Command{
Use: "peer",
PersistentPreRunE: func(cmd *cobra.Command, args []string) error {
peerCommand := getPeerCommandFromCobraCommand(cmd)
flogging.LoggingInit(peerCommand)
return core.CacheConfiguration()
},
Run: func(cmd *cobra.Command, args []string) {
if versionFlag {
version.Print()
} else {
cmd.HelpFunc()(cmd, args)
}
},
}
// Peer command version flag
var versionFlag bool
// NewECA sets up a new ECA.
//
func NewECA(aca *ACA) *ECA {
eca := &ECA{CA: NewCA("eca", initializeECATables), aca: aca}
flogging.LoggingInit("eca")
{
// read or create global symmetric encryption key
var cooked string
var l = logging.MustGetLogger("ECA")
raw, err := ioutil.ReadFile(eca.path + "/obc.aes")
if err != nil {
rand := rand.Reader
key := make([]byte, 32) // AES-256
rand.Read(key)
cooked = base64.StdEncoding.EncodeToString(key)
err = ioutil.WriteFile(eca.path+"/obc.aes", []byte(cooked), 0644)
if err != nil {
l.Panic(err)
}
} else {
cooked = string(raw)
}
eca.obcKey, err = base64.StdEncoding.DecodeString(cooked)
if err != nil {
l.Panic(err)
}
}
{
// read or create global ECDSA key pair for ECIES
var priv *ecdsa.PrivateKey
cooked, err := ioutil.ReadFile(eca.path + "/obc.ecies")
if err == nil {
block, _ := pem.Decode(cooked)
priv, err = x509.ParseECPrivateKey(block.Bytes)
if err != nil {
ecaLogger.Panic(err)
}
} else {
priv, err = ecdsa.GenerateKey(primitives.GetDefaultCurve(), rand.Reader)
if err != nil {
ecaLogger.Panic(err)
}
raw, _ := x509.MarshalECPrivateKey(priv)
cooked = pem.EncodeToMemory(
&pem.Block{
Type: "ECDSA PRIVATE KEY",
Bytes: raw,
})
err := ioutil.WriteFile(eca.path+"/obc.ecies", cooked, 0644)
if err != nil {
ecaLogger.Panic(err)
}
}
eca.obcPriv = cooked
raw, _ := x509.MarshalPKIXPublicKey(&priv.PublicKey)
eca.obcPub = pem.EncodeToMemory(
&pem.Block{
Type: "ECDSA PUBLIC KEY",
Bytes: raw,
})
}
eca.populateAffiliationGroupsTable()
eca.populateUsersTable()
return eca
}
func main() {
viper.SetEnvPrefix(envPrefix)
viper.AutomaticEnv()
replacer := strings.NewReplacer(".", "_")
viper.SetEnvKeyReplacer(replacer)
viper.SetConfigName("membersrvc")
viper.SetConfigType("yaml")
viper.AddConfigPath("./")
// Path to look for the config file based on GOPATH
gopath := os.Getenv("GOPATH")
for _, p := range filepath.SplitList(gopath) {
cfgpath := filepath.Join(p, "src/github.com/hyperledger/fabric/membersrvc")
viper.AddConfigPath(cfgpath)
}
err := viper.ReadInConfig()
if err != nil {
logger.Panicf("Fatal error when reading %s config file: %s", "membersrvc", err)
}
flogging.LoggingInit("server")
// Init the crypto layer
if err := crypto.Init(); err != nil {
logger.Panicf("Failed initializing the crypto layer [%s]", err)
}
// cache configure
ca.CacheConfiguration()
logger.Infof("CA Server (" + metadata.Version + ")")
aca := ca.NewACA()
defer aca.Stop()
eca := ca.NewECA(aca)
defer eca.Stop()
tca := ca.NewTCA(eca)
defer tca.Stop()
tlsca := ca.NewTLSCA(eca)
defer tlsca.Stop()
runtime.GOMAXPROCS(viper.GetInt("server.gomaxprocs"))
var opts []grpc.ServerOption
if viper.GetString("server.tls.cert.file") != "" {
creds, err := credentials.NewServerTLSFromFile(viper.GetString("server.tls.cert.file"), viper.GetString("server.tls.key.file"))
if err != nil {
logger.Panic(err)
}
opts = []grpc.ServerOption{grpc.Creds(creds)}
}
srv := grpc.NewServer(opts...)
if viper.GetBool("aca.enabled") {
aca.Start(srv)
}
eca.Start(srv)
tca.Start(srv)
tlsca.Start(srv)
if sock, err := net.Listen("tcp", viper.GetString("server.port")); err != nil {
logger.Errorf("Fail to start CA Server: %s", err)
os.Exit(1)
} else {
srv.Serve(sock)
sock.Close()
}
}
