func setup() {
// Conf
viper.SetConfigName("openchain") // name of config file (without extension)
viper.AddConfigPath(".") // path to look for the config file in
err := viper.ReadInConfig() // Find and read the config file
if err != nil { // Handle errors reading the config file
panic(fmt.Errorf("Fatal error config file [%s] \n", err))
}
// Logging
var formatter = logging.MustStringFormatter(
`%{color}[%{module}] %{shortfunc} [%{shortfile}] -> %{level:.4s} %{id:03x}%{color:reset} %{message}`,
)
logging.SetFormatter(formatter)
logging.SetLevel(logging.DEBUG, "peer")
logging.SetLevel(logging.DEBUG, "chaincode")
logging.SetLevel(logging.DEBUG, "cryptoain")
// Init the crypto layer
if err := crypto.Init(); err != nil {
panic(fmt.Errorf("Failed initializing the crypto layer [%s]%", err))
}
viper.Set("peer.fileSystemPath", filepath.Join(os.TempDir(), "openchain", "production"))
viper.Set("server.rootpath", filepath.Join(os.TempDir(), "obcca"))
removeFolders()
}
func main() {
runtime.GOMAXPROCS(2)
// For environment variables.
viper.SetEnvPrefix(cmdRoot)
viper.AutomaticEnv()
replacer := strings.NewReplacer(".", "_")
viper.SetEnvKeyReplacer(replacer)
// Define command-line flags that are valid for all obc-peer commands and
// subcommands.
mainFlags := mainCmd.PersistentFlags()
mainFlags.String("logging-level", "", "Default logging level and overrides, see openchain.yaml for full syntax")
viper.BindPFlag("logging_level", mainFlags.Lookup("logging-level"))
// Set the flags on the peer command.
flags := peerCmd.Flags()
flags.Bool("peer-tls-enabled", false, "Connection uses TLS if true, else plain TCP")
flags.String("peer-tls-cert-file", "testdata/server1.pem", "TLS cert file")
flags.String("peer-tls-key-file", "testdata/server1.key", "TLS key file")
flags.Int("peer-port", 30303, "Port this peer listens to for incoming connections")
flags.Int("peer-gomaxprocs", 2, "The maximum number threads excuting peer code")
flags.Bool("peer-discovery-enabled", true, "Whether peer discovery is enabled")
flags.BoolVarP(&chaincodeDevMode, "peer-chaincodedev", "", false, "Whether peer in chaincode development mode")
viper.BindPFlag("peer_tls_enabled", flags.Lookup("peer-tls-enabled"))
viper.BindPFlag("peer_tls_cert_file", flags.Lookup("peer-tls-cert-file"))
viper.BindPFlag("peer_tls_key_file", flags.Lookup("peer-tls-key-file"))
viper.BindPFlag("peer_port", flags.Lookup("peer-port"))
viper.BindPFlag("peer_gomaxprocs", flags.Lookup("peer-gomaxprocs"))
viper.BindPFlag("peer_discovery_enabled", flags.Lookup("peer-discovery-enabled"))
// Now set the configuration file.
viper.SetConfigName(cmdRoot) // Name of config file (without extension)
viper.AddConfigPath("./") // Path to look for the config file in
err := viper.ReadInConfig() // Find and read the config file
if err != nil { // Handle errors reading the config file
panic(fmt.Errorf("Fatal error when reading %s config file: %s \n", cmdRoot, err))
}
mainCmd.AddCommand(peerCmd)
mainCmd.AddCommand(statusCmd)
mainCmd.AddCommand(stopCmd)
mainCmd.AddCommand(loginCmd)
vmCmd.AddCommand(vmPrimeCmd)
mainCmd.AddCommand(vmCmd)
mainCmd.AddCommand(networkCmd)
chaincodeCmd.PersistentFlags().StringVarP(&chaincodeLang, "lang", "l", "golang", fmt.Sprintf("Language the %s is written in", chainFuncName))
chaincodeCmd.PersistentFlags().StringVarP(&chaincodeCtorJSON, "ctor", "c", "{}", fmt.Sprintf("Constructor message for the %s in JSON format", chainFuncName))
chaincodeCmd.PersistentFlags().StringVarP(&chaincodePath, "path", "p", undefinedParamValue, fmt.Sprintf("Path to %s", chainFuncName))
chaincodeCmd.PersistentFlags().StringVarP(&chaincodeName, "name", "n", undefinedParamValue, fmt.Sprintf("Name of the chaincode returned by the deploy transaction"))
chaincodeCmd.PersistentFlags().StringVarP(&chaincodeUsr, "username", "u", undefinedParamValue, fmt.Sprintf("Username for chaincode operations when security is enabled"))
chaincodeQueryCmd.Flags().BoolVarP(&chaincodeQueryRaw, "raw", "r", false, "If true, output the query value as raw bytes, otherwise format as a printable string")
chaincodeQueryCmd.Flags().BoolVarP(&chaincodeQueryHex, "hex", "x", false, "If true, output the query value byte array in hexadecimal. Incompatible with --raw")
chaincodeCmd.AddCommand(chaincodeDeployCmd)
chaincodeCmd.AddCommand(chaincodeInvokeCmd)
chaincodeCmd.AddCommand(chaincodeQueryCmd)
mainCmd.AddCommand(chaincodeCmd)
// Init the crypto layer
if err := crypto.Init(); err != nil {
panic(fmt.Errorf("Failed initializing the crypto layer [%s]%", err))
}
// On failure Cobra prints the usage message and error string, so we only
// need to exit with a non-0 status
if mainCmd.Execute() != nil {
os.Exit(1)
}
}
func main() {
viper.AutomaticEnv()
viper.SetConfigName("obcca")
viper.SetConfigType("yaml")
viper.AddConfigPath("./")
err := viper.ReadInConfig()
if err != nil {
panic(err)
}
var iotrace, ioinfo, iowarning, ioerror, iopanic io.Writer
if obcca.GetConfigInt("logging.trace") == 1 {
iotrace = os.Stdout
} else {
iotrace = ioutil.Discard
}
if obcca.GetConfigInt("logging.info") == 1 {
ioinfo = os.Stdout
} else {
ioinfo = ioutil.Discard
}
if obcca.GetConfigInt("logging.warning") == 1 {
iowarning = os.Stdout
} else {
iowarning = ioutil.Discard
}
if obcca.GetConfigInt("logging.error") == 1 {
ioerror = os.Stderr
} else {
ioerror = ioutil.Discard
}
if obcca.GetConfigInt("logging.panic") == 1 {
iopanic = os.Stdout
} else {
iopanic = ioutil.Discard
}
// Init the crypto layer
if err := crypto.Init(); err != nil {
panic(fmt.Errorf("Failed initializing the crypto layer [%s]%", err))
}
obcca.LogInit(iotrace, ioinfo, iowarning, ioerror, iopanic)
obcca.Info.Println("CA Server (" + viper.GetString("server.version") + ")")
eca := obcca.NewECA()
defer eca.Close()
tca := obcca.NewTCA(eca)
defer tca.Close()
tlsca := obcca.NewTLSCA(eca)
defer tlsca.Close()
runtime.GOMAXPROCS(obcca.GetConfigInt("server.gomaxprocs"))
var opts []grpc.ServerOption
if viper.GetString("server.tls.certfile") != "" {
creds, err := credentials.NewServerTLSFromFile(viper.GetString("server.tls.certfile"), viper.GetString("server.tls.keyfile"))
if err != nil {
panic(err)
}
opts = []grpc.ServerOption{grpc.Creds(creds)}
}
srv := grpc.NewServer(opts...)
eca.Start(srv)
tca.Start(srv)
tlsca.Start(srv)
sock, err := net.Listen("tcp", obcca.GetConfigString("server.port"))
if err != nil {
panic(err)
}
srv.Serve(sock)
sock.Close()
}