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() } }