func InitConfig() {
viper.SetConfigName("scds")
viper.SetConfigType("yaml")
viper.SetEnvPrefix("scds")
viper.AutomaticEnv()
// Replaces underscores with periods when mapping environment variables.
viper.SetEnvKeyReplacer(strings.NewReplacer(".", "_"))
// Set non-zero defaults. Nested options take a lower precedence than
// dot-delimited ones, so namespaced options are defined here as maps.
viper.SetDefault("mongo", map[string]interface{}{
"uri": "localhost/scds",
})
viper.SetDefault("http", map[string]interface{}{
"host": "localhost",
"port": 5000,
})
viper.SetDefault("smtp", map[string]interface{}{
"host": "localhost",
"port": 25,
})
// Read the default config file from the working directory.
dir, err := os.Getwd()
if err != nil {
log.Fatal(err)
}
viper.AddConfigPath(dir)
}
func init() {
viper.SetConfigType("yaml")
viper.AutomaticEnv()
envReplacer := strings.NewReplacer(".", "_")
viper.SetEnvKeyReplacer(envReplacer)
}
// Start entry point for chaincodes bootstrap.
func Start(cc Chaincode) error {
viper.SetEnvPrefix("OPENCHAIN")
viper.AutomaticEnv()
replacer := strings.NewReplacer(".", "_")
viper.SetEnvKeyReplacer(replacer)
flag.StringVar(&peerAddress, "peer.address", "", "peer address")
flag.Parse()
chaincodeLogger.Debug("Peer address: %s", getPeerAddress())
// Establish connection with validating peer
clientConn, err := newPeerClientConnection()
if err != nil {
chaincodeLogger.Error(fmt.Sprintf("Error trying to connect to local peer: %s", err))
return fmt.Errorf("Error trying to connect to local peer: %s", err)
}
chaincodeLogger.Debug("os.Args returns: %s", os.Args)
chaincodeSupportClient := pb.NewChaincodeSupportClient(clientConn)
err = chatWithPeer(chaincodeSupportClient, cc)
return err
}
// Start entry point for chaincodes bootstrap.
func Start(cc Chaincode) error {
viper.SetEnvPrefix("OPENCHAIN")
viper.AutomaticEnv()
replacer := strings.NewReplacer(".", "_")
viper.SetEnvKeyReplacer(replacer)
/*
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))
}
*/
fmt.Printf("peer.address: %s\n", getPeerAddress())
// Establish connection with validating peer
clientConn, err := newPeerClientConnection()
if err != nil {
return fmt.Errorf("Error trying to connect to local peer: %s", err)
}
fmt.Printf("os.Args returns: %s\n", os.Args)
chaincodeSupportClient := pb.NewChaincodeSupportClient(clientConn)
//err = c.Run(chaincodeSupportClient)
//if err != nil {
//}
// Handle message exchange with validating peer
err = chatWithPeer(chaincodeSupportClient, cc)
return err
}
// Setup sets up defaults for viper configuration options and
// overrides these values with the values from the given configuration file
// if it is not empty. Those values again are overwritten by environment
// variables.
func Setup(configFilePath string) error {
viper.Reset()
// Expect environment variables to be prefix with "ALMIGHTY_".
viper.SetEnvPrefix("ALMIGHTY")
// Automatically map environment variables to viper values
viper.AutomaticEnv()
// To override nested variables through environment variables, we
// need to make sure that we don't have to use dots (".") inside the
// environment variable names.
// To override foo.bar you need to set ALM_FOO_BAR
viper.SetEnvKeyReplacer(strings.NewReplacer(".", "_"))
viper.SetTypeByDefaultValue(true)
setConfigDefaults()
// Read the config
// Explicitly specify which file to load config from
if configFilePath != "" {
viper.SetConfigFile(configFilePath)
viper.SetConfigType("yaml")
err := viper.ReadInConfig() // Find and read the config file
if err != nil { // Handle errors reading the config file
return fmt.Errorf("Fatal error config file: %s \n", err)
}
}
return nil
}
// Start entry point for chaincodes bootstrap.
func Start(cc Chaincode) error {
viper.SetEnvPrefix("CORE")
viper.AutomaticEnv()
replacer := strings.NewReplacer(".", "_")
viper.SetEnvKeyReplacer(replacer)
flag.StringVar(&peerAddress, "peer.address", "", "peer address")
flag.Parse()
chaincodeLogger.Debug("Peer address: %s", getPeerAddress())
// Establish connection with validating peer
clientConn, err := newPeerClientConnection()
if err != nil {
chaincodeLogger.Error(fmt.Sprintf("Error trying to connect to local peer: %s", err))
return fmt.Errorf("Error trying to connect to local peer: %s", err)
}
chaincodeLogger.Debug("os.Args returns: %s", os.Args)
chaincodeSupportClient := pb.NewChaincodeSupportClient(clientConn)
// Establish stream with validating peer
stream, err := chaincodeSupportClient.Register(context.Background())
if err != nil {
return fmt.Errorf("Error chatting with leader at address=%s: %s", getPeerAddress(), err)
}
chaincodename := viper.GetString("chaincode.id.name")
err = chatWithPeer(chaincodename, stream, cc)
return err
}
func main() {
// For environment variables.
viper.SetEnvPrefix(cmdRoot)
viper.AutomaticEnv()
replacer := strings.NewReplacer(".", "_")
viper.SetEnvKeyReplacer(replacer)
// Define command-line flags that are valid for all peer commands and
// subcommands.
mainFlags := mainCmd.PersistentFlags()
mainFlags.BoolVarP(&versionFlag, "version", "v", false, "Display current version of fabric peer server")
mainFlags.String("logging-level", "", "Default logging level and overrides, see core.yaml for full syntax")
viper.BindPFlag("logging_level", mainFlags.Lookup("logging-level"))
testCoverProfile := ""
mainFlags.StringVarP(&testCoverProfile, "test.coverprofile", "", "coverage.cov", "Done")
var alternativeCfgPath = os.Getenv("PEER_CFG_PATH")
if alternativeCfgPath != "" {
logger.Infof("User defined config file path: %s", alternativeCfgPath)
viper.AddConfigPath(alternativeCfgPath) // Path to look for the config file in
} else {
viper.AddConfigPath("./") // Path to look for the config file in
// Path to look for the config file in based on GOPATH
gopath := os.Getenv("GOPATH")
for _, p := range filepath.SplitList(gopath) {
peerpath := filepath.Join(p, "src/github.com/hyperledger/fabric/peer")
viper.AddConfigPath(peerpath)
}
}
// Now set the configuration file.
viper.SetConfigName(cmdRoot) // Name of config file (without extension)
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(version.Cmd())
mainCmd.AddCommand(node.Cmd())
mainCmd.AddCommand(network.Cmd())
mainCmd.AddCommand(chaincode.Cmd())
runtime.GOMAXPROCS(viper.GetInt("peer.gomaxprocs"))
// Init the crypto layer
if err := crypto.Init(); err != nil {
panic(fmt.Errorf("Failed to initialize 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)
}
logger.Info("Exiting.....")
}
func init() {
envReplacer = strings.NewReplacer(".", "_")
// Configure Viper to search for all configurations
// in the system environment variables
viper.SetEnvPrefix(envPrefix)
viper.AutomaticEnv()
viper.SetEnvKeyReplacer(envReplacer)
}
func setupViper() {
viper.SetEnvPrefix(constants.MinikubeEnvPrefix)
// Replaces '-' in flags with '_' in env variables
// e.g. show-libmachine-logs => $ENVPREFIX_SHOW_LIBMACHINE_LOGS
viper.SetEnvKeyReplacer(strings.NewReplacer("-", "_"))
viper.AutomaticEnv()
viper.SetDefault(config.WantUpdateNotification, true)
viper.SetDefault(config.ReminderWaitPeriodInHours, 24)
setFlagsUsingViper()
}
// SetupCoreYAMLConfig sets up configurations for testing
func SetupCoreYAMLConfig(coreYamlPath string) {
viper.SetConfigName("core")
viper.SetEnvPrefix("CORE")
viper.AddConfigPath(coreYamlPath)
viper.SetEnvKeyReplacer(strings.NewReplacer(".", "_"))
viper.AutomaticEnv()
err := viper.ReadInConfig()
if err != nil { // Handle errors reading the config file
panic(fmt.Errorf("Fatal error config file: %s \n", err))
}
}
func init() {
// set default log level to Error
viper.SetDefault("logging", map[string]interface{}{"level": 2})
viper.SetEnvPrefix(envPrefix)
viper.SetEnvKeyReplacer(strings.NewReplacer(".", "_"))
viper.AutomaticEnv()
// Setup flags
flag.StringVar(&configFile, "config", "", "Path to configuration file")
flag.BoolVar(&debug, "debug", false, "show the version and exit")
}
func main() {
rootCmd := &cobra.Command{
Use: "mantl-api",
Short: "runs the mantl-api",
Run: func(cmd *cobra.Command, args []string) {
start()
},
PersistentPreRun: func(cmd *cobra.Command, args []string) {
readConfigFile()
setupLogging()
},
}
rootCmd.PersistentFlags().String("log-level", "info", "one of debug, info, warn, error, or fatal")
rootCmd.PersistentFlags().String("log-format", "text", "specify output (text or json)")
rootCmd.PersistentFlags().String("consul", "http://localhost:8500", "Consul Api address")
rootCmd.PersistentFlags().String("marathon", "", "Marathon Api address")
rootCmd.PersistentFlags().String("marathon-user", "", "Marathon Api user")
rootCmd.PersistentFlags().String("marathon-password", "", "Marathon Api password")
rootCmd.PersistentFlags().Bool("marathon-no-verify-ssl", false, "Marathon SSL verification")
rootCmd.PersistentFlags().String("mesos", "", "Mesos Api address")
rootCmd.PersistentFlags().String("mesos-principal", "", "Mesos principal for framework authentication")
rootCmd.PersistentFlags().String("mesos-secret", "", "Mesos secret for framework authentication")
rootCmd.PersistentFlags().Bool("mesos-no-verify-ssl", false, "Mesos SSL verification")
rootCmd.PersistentFlags().String("listen", ":4001", "mantl-api listen address")
rootCmd.PersistentFlags().String("zookeeper", "", "Comma-delimited list of zookeeper servers")
rootCmd.PersistentFlags().Bool("force-sync", false, "Force a synchronization of all sources")
rootCmd.PersistentFlags().String("config-file", "", "The path to a configuration file")
for _, flags := range []*pflag.FlagSet{rootCmd.PersistentFlags()} {
err := viper.BindPFlags(flags)
if err != nil {
log.WithField("error", err).Fatal("could not bind flags")
}
}
viper.SetEnvPrefix("mantl_api")
viper.SetEnvKeyReplacer(strings.NewReplacer("-", "_"))
viper.AutomaticEnv()
syncCommand := &cobra.Command{
Use: "sync",
Short: "Synchronize universe repositories",
Long: "Forces a synchronization of all configured sources",
Run: func(cmd *cobra.Command, args []string) {
sync(nil, true)
},
}
rootCmd.AddCommand(syncCommand)
rootCmd.Execute()
}
// TODO: Need to look at whether this is just too much going on.
func init() {
// enable ability to specify config file via flag
RootCmd.PersistentFlags().StringVar(&cfgFile, "config", "", "config file (default is $HOME/.trackello.yaml)")
if cfgFile != "" {
viper.SetConfigFile(cfgFile)
}
viper.SetConfigName(".trackello") // name of config file (without extension)
// Set Environment Variables
viper.SetEnvPrefix("trackello")
viper.SetEnvKeyReplacer(strings.NewReplacer("-", "_")) // replace environment variables to underscore (_) from hyphen (-)
if err := viper.BindEnv("appkey", trackello.TRACKELLO_APPKEY); err != nil {
panic(err)
}
if err := viper.BindEnv("token", trackello.TRACKELLO_TOKEN); err != nil {
panic(err)
}
if err := viper.BindEnv("board", trackello.TRACKELLO_PREFERRED_BOARD); err != nil {
panic(err)
}
viper.AutomaticEnv() // read in environment variables that match every time Get() is called
// Add Configuration Paths
if cwd, err := os.Getwd(); err == nil {
viper.AddConfigPath(cwd)
}
viper.AddConfigPath("$HOME") // adding home directory as first search path
// If a config file is found, read it in.
if err := viper.ReadInConfig(); err == nil {
fmt.Println("Using config file:", viper.ConfigFileUsed())
}
RootCmd.AddCommand(configCmd)
RootCmd.PersistentFlags().StringVar(&trelloAppKey, "appkey", "", "Trello Application Key")
if err := viper.BindPFlag("appkey", RootCmd.PersistentFlags().Lookup("appkey")); err != nil {
panic(err)
}
RootCmd.PersistentFlags().StringVar(&trelloToken, "token", "", "Trello Token")
if err := viper.BindPFlag("token", RootCmd.PersistentFlags().Lookup("token")); err != nil {
panic(err)
}
RootCmd.PersistentFlags().StringVar(&preferredBoard, "board", "", "Preferred Board ID")
if err := viper.BindPFlag("board", RootCmd.PersistentFlags().Lookup("board")); err != nil {
panic(err)
}
viper.RegisterAlias("preferredBoard", "board")
}
// SetChaincodeLoggingLevel sets the chaincode logging level to the value
// of CORE_LOGGING_CHAINCODE set from core.yaml by chaincode_support.go
func SetChaincodeLoggingLevel() {
viper.SetEnvPrefix("CORE")
viper.AutomaticEnv()
replacer := strings.NewReplacer(".", "_")
viper.SetEnvKeyReplacer(replacer)
chaincodeLogLevelString := viper.GetString("logging.chaincode")
chaincodeLogLevel, err := LogLevel(chaincodeLogLevelString)
if err == nil {
SetLoggingLevel(chaincodeLogLevel)
} else {
chaincodeLogger.Infof("error with chaincode log level: %s level= %s\n", err, chaincodeLogLevelString)
}
}
func main() {
cnf := config.NewConfig()
cnf.AddFlags(pflag.CommandLine)
cnf.InitFlags()
viper.SetEnvPrefix("tinysyslog")
replacer := strings.NewReplacer("-", "_")
viper.SetEnvKeyReplacer(replacer)
viper.AutomaticEnv()
InitLogging()
server := NewServer()
server.Run()
}
// initConfig reads in config file and ENV variables if set.
func initConfig() {
if cfgFile != "" { // enable ability to specify config file via flag
viper.SetConfigFile(cfgFile)
}
viper.SetEnvPrefix("FISSILE")
viper.SetEnvKeyReplacer(strings.NewReplacer("-", "_"))
viper.SetConfigName(".fissile") // name of config file (without extension)
viper.AddConfigPath("$HOME") // adding home directory as first search path
viper.AutomaticEnv() // read in environment variables that match
// If a config file is found, read it in.
if err := viper.ReadInConfig(); err == nil {
fmt.Println("Using config file:", viper.ConfigFileUsed())
}
}
// SetupTestConfig setup the config during test execution
func SetupTestConfig() {
flag.Parse()
// Now set the configuration file
viper.SetEnvPrefix("CORE")
viper.AutomaticEnv()
replacer := strings.NewReplacer(".", "_")
viper.SetEnvKeyReplacer(replacer)
viper.SetConfigName("core") // name of config file (without extension)
viper.AddConfigPath("../../peer/") // 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))
}
SetupTestLogging()
}
func SetupTestConfig() {
viper.AddConfigPath(".")
viper.SetEnvKeyReplacer(strings.NewReplacer(".", "_"))
viper.AutomaticEnv()
viper.SetDefault("peer.ledger.test.loadYAML", true)
loadYAML := viper.GetBool("peer.ledger.test.loadYAML")
if loadYAML {
viper.SetConfigName("test")
err := viper.ReadInConfig()
if err != nil { // Handle errors reading the config file
panic(fmt.Errorf("Fatal error config file: %s \n", err))
}
}
var formatter = logging.MustStringFormatter(
`%{color}%{time:15:04:05.000} [%{module}] %{shortfunc} [%{shortfile}] -> %{level:.4s} %{id:03x}%{color:reset} %{message}`,
)
logging.SetFormatter(formatter)
}
// SetupTestConfig setup the config during test execution
func SetupTestConfig() {
runtime.GOMAXPROCS(runtime.NumCPU())
flag.Parse()
// Now set the configuration file
viper.SetEnvPrefix("OPENCHAIN")
viper.AutomaticEnv()
replacer := strings.NewReplacer(".", "_")
viper.SetEnvKeyReplacer(replacer)
viper.SetConfigName("openchain") // name of config file (without extension)
viper.AddConfigPath("./") // path to look for the config file in
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))
}
SetupTestLogging()
}
// SetChaincodeLoggingLevel sets the chaincode logging level to the value
// of CORE_LOGGING_CHAINCODE set from core.yaml by chaincode_support.go
func SetChaincodeLoggingLevel() {
viper.SetEnvPrefix("CORE")
viper.AutomaticEnv()
replacer := strings.NewReplacer(".", "_")
viper.SetEnvKeyReplacer(replacer)
chaincodeLogLevelString := viper.GetString("logging.chaincode")
if chaincodeLogLevelString == "" {
shimLogLevelDefault := logging.Level(shimLoggingLevel)
chaincodeLogger.Infof("Chaincode log level not provided; defaulting to: %s", shimLogLevelDefault)
} else {
chaincodeLogLevel, err := LogLevel(chaincodeLogLevelString)
if err == nil {
SetLoggingLevel(chaincodeLogLevel)
} else {
chaincodeLogger.Warningf("Error: %s for chaincode log level: %s", err, chaincodeLogLevelString)
}
}
}
// Start is the entry point for chaincodes bootstrap. It is not an API for
// chaincodes.
func Start(cc Chaincode) error {
// If Start() is called, we assume this is a standalone chaincode and set
// up formatted logging.
format := logging.MustStringFormatter("%{time:15:04:05.000} [%{module}] %{level:.4s} : %{message}")
backend := logging.NewLogBackend(os.Stderr, "", 0)
backendFormatter := logging.NewBackendFormatter(backend, format)
logging.SetBackend(backendFormatter).SetLevel(logging.Level(shimLoggingLevel), "shim")
viper.SetEnvPrefix("CORE")
viper.AutomaticEnv()
replacer := strings.NewReplacer(".", "_")
viper.SetEnvKeyReplacer(replacer)
flag.StringVar(&peerAddress, "peer.address", "", "peer address")
flag.Parse()
chaincodeLogger.Debugf("Peer address: %s", getPeerAddress())
// Establish connection with validating peer
clientConn, err := newPeerClientConnection()
if err != nil {
chaincodeLogger.Errorf("Error trying to connect to local peer: %s", err)
return fmt.Errorf("Error trying to connect to local peer: %s", err)
}
chaincodeLogger.Debugf("os.Args returns: %s", os.Args)
chaincodeSupportClient := pb.NewChaincodeSupportClient(clientConn)
// Establish stream with validating peer
stream, err := chaincodeSupportClient.Register(context.Background())
if err != nil {
return fmt.Errorf("Error chatting with leader at address=%s: %s", getPeerAddress(), err)
}
chaincodename := viper.GetString("chaincode.id.name")
err = chatWithPeer(chaincodename, stream, cc)
return err
}
// SetupTestConfig setup the config during test execution
func SetupTestConfig() {
flag.Parse()
// Now set the configuration file
viper.SetEnvPrefix("CORE")
viper.AutomaticEnv()
replacer := strings.NewReplacer(".", "_")
viper.SetEnvKeyReplacer(replacer)
viper.SetConfigName("chaincodetest") // 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))
}
SetupTestLogging()
// Set the number of maxprocs
var numProcsDesired = viper.GetInt("peer.gomaxprocs")
chaincodeLogger.Debug("setting Number of procs to %d, was %d\n", numProcsDesired, runtime.GOMAXPROCS(2))
}
func Init(name ...string) {
if len(name) == 1 {
appName = name[0]
}
viper.SetEnvPrefix(appName)
viper.AutomaticEnv()
viper.SetEnvKeyReplacer(strings.NewReplacer(".", "_"))
configPath := os.Getenv("CFG_PATH")
if configPath != "" {
viper.AddConfigPath(configPath)
} else {
viper.AddConfigPath("./")
viper.AddConfigPath("conf/")
}
viper.SetConfigName(appName)
err := viper.ReadInConfig()
if err != nil {
panic(fmt.Errorf("Fatal error when reading %s config file: %s\n", appName, err))
}
switch viper.GetString("logging.level") {
case "debug", "d":
log.SetLevel(log.DebugLevel)
case "info", "i":
log.SetLevel(log.InfoLevel)
case "warning", "w":
log.SetLevel(log.WarnLevel)
case "error", "e":
log.SetLevel(log.ErrorLevel)
default:
}
log.SetFormatter(new(log.JSONFormatter))
}
// initConfig reads in config file and ENV variables if set.
func initConfig() {
viper.SetConfigType("yaml")
viper.SetConfigName(".ttn") // name of config file (without extension)
viper.AddConfigPath("$HOME") // adding home directory as first search path
viper.SetEnvPrefix("ttn") // set environment prefix
viper.SetEnvKeyReplacer(strings.NewReplacer(".", "_", "-", "_"))
viper.AutomaticEnv() // read in environment variables that match
if cfgFile != "" { // enable ability to specify config file via flag
viper.SetConfigFile(cfgFile)
}
viper.BindEnv("debug")
// If a config file is found, read it in.
err := viper.ReadInConfig()
if err != nil {
fmt.Println("Error when reading config file:", err)
os.Exit(1)
} else if err == nil {
fmt.Println("Using config file:", viper.ConfigFileUsed())
}
}
func main() {
viper.SetEnvPrefix(appNameEnv)
viper.AutomaticEnv()
replacer := strings.NewReplacer("-", "_")
viper.SetEnvKeyReplacer(replacer)
appCmd := &cobra.Command{
Use: appName,
Short: appName + " dumps content of Bolt file",
Long: "Dump Bolt database - use to check content",
Run: func(cmd *cobra.Command, args []string) {
dbName = viper.GetString("db")
fmt.Printf("Database name: %s\n", dbName)
DumpStore(dbName)
},
}
appCmd.Flags().StringVarP(&dbName, "db", "", defaultBoltName, "name of the bolt database file"+" (env: "+appNameEnv+"_DB "+")")
viper.BindPFlag("db", appCmd.Flags().Lookup("db"))
appCmd.Execute()
}
func main() {
runtime.GOMAXPROCS(2)
// For environment variables.
viper.SetEnvPrefix(cmdRoot)
viper.AutomaticEnv()
replacer := strings.NewReplacer(".", "_")
viper.SetEnvKeyReplacer(replacer)
// Set the flags on the server command.
flags := peerCmd.Flags()
flags.String("peer-logging-level", "error", "Logging level, can be one of [CRITICAL | ERROR | WARNING | NOTICE | INFO | DEBUG]")
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_logging_level", flags.Lookup("peer-logging-level"))
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))
}
level, err := logging.LogLevel(viper.GetString("peer.logging.level"))
if err == nil {
// No error, use the setting.
logging.SetLevel(level, chainFuncName)
logging.SetLevel(level, "consensus")
logging.SetLevel(level, "consensus/controller")
logging.SetLevel(level, "consensus/helper")
logging.SetLevel(level, "consensus/noops")
logging.SetLevel(level, "consensus/pbft")
logging.SetLevel(level, "main")
logging.SetLevel(level, "peer")
logging.SetLevel(level, "server")
} else {
logger.Warning("Log level not recognized '%s', defaulting to %s: %s", viper.GetString("peer.logging.level"), logging.ERROR, err)
logging.SetLevel(logging.ERROR, chainFuncName)
logging.SetLevel(logging.ERROR, "consensus")
logging.SetLevel(logging.ERROR, "consensus/controller")
logging.SetLevel(logging.ERROR, "consensus/helper")
logging.SetLevel(logging.ERROR, "consensus/noops")
logging.SetLevel(logging.ERROR, "consensus/pbft")
logging.SetLevel(logging.ERROR, "main")
logging.SetLevel(logging.ERROR, "peer")
logging.SetLevel(logging.ERROR, "server")
}
mainCmd.AddCommand(peerCmd)
mainCmd.AddCommand(statusCmd)
mainCmd.AddCommand(stopCmd)
mainCmd.AddCommand(loginCmd)
vmCmd.AddCommand(vmPrimeCmd)
mainCmd.AddCommand(vmCmd)
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"))
chaincodeCmd.AddCommand(chaincodeDeployCmd)
chaincodeCmd.AddCommand(chaincodeInvokeCmd)
chaincodeCmd.AddCommand(chaincodeQueryCmd)
mainCmd.AddCommand(chaincodeCmd)
mainCmd.Execute()
}
// NewContext created new context for settings
func NewContext(c *cobra.Command) {
repl := strings.NewReplacer(".", "_")
viper.SetEnvPrefix("kanban")
viper.SetEnvKeyReplacer(repl)
viper.SetDefault("server.listen", "0.0.0.0:80")
viper.BindEnv("server.listen")
if c.Flags().Lookup("server-listen").Changed {
viper.BindPFlag("server.listen", c.Flags().Lookup("server-listen"))
}
viper.SetDefault("server.hostname", "http://localhost")
viper.BindEnv("server.hostname")
if c.Flags().Lookup("server-hostname").Changed {
viper.BindPFlag("server.hostname", c.Flags().Lookup("server-hostname"))
}
viper.SetDefault("security.secret", "qwerty")
viper.BindEnv("security.secret")
if c.Flags().Lookup("security-secret").Changed {
viper.BindPFlag("security.secret", c.Flags().Lookup("security-secret"))
}
viper.SetDefault("gitlab.url", "https://gitlab.com")
viper.BindEnv("gitlab.url")
if c.Flags().Lookup("gitlab-url").Changed {
viper.BindPFlag("gitlab.url", c.Flags().Lookup("gitlab-url"))
}
viper.SetDefault("gitlab.client", "qwerty")
viper.BindEnv("gitlab.client")
if c.Flags().Lookup("gitlab-client").Changed {
viper.BindPFlag("gitlab.client", c.Flags().Lookup("gitlab-client"))
}
viper.SetDefault("gitlab.secret", "qwerty")
viper.BindEnv("gitlab.secret")
if c.Flags().Lookup("gitlab-secret").Changed {
viper.BindPFlag("gitlab.secret", c.Flags().Lookup("gitlab-secret"))
}
viper.SetDefault("redis.addr", "127.0.0.1:6379")
viper.BindEnv("redis.addr")
if c.Flags().Lookup("redis-addr").Changed {
viper.BindPFlag("redis.addr", c.Flags().Lookup("redis-addr"))
}
viper.SetDefault("redis.password", "")
viper.BindEnv("redis.password")
if c.Flags().Lookup("redis-password").Changed {
viper.BindPFlag("redis.password", c.Flags().Lookup("redis-password"))
}
viper.SetDefault("redis.db", 0)
viper.BindEnv("redis.db")
if c.Flags().Lookup("redis-db").Changed {
viper.BindPFlag("redis.db", c.Flags().Lookup("redis-db"))
}
viper.SetDefault("version", "1.4.1")
}
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 {
panic(fmt.Errorf("Fatal error when reading %s config file: %s\n", "membersrvc", err))
}
var iotrace, ioinfo, iowarning, ioerror, iopanic io.Writer
if viper.GetInt("logging.trace") == 1 {
iotrace = os.Stdout
} else {
iotrace = ioutil.Discard
}
if viper.GetInt("logging.info") == 1 {
ioinfo = os.Stdout
} else {
ioinfo = ioutil.Discard
}
if viper.GetInt("logging.warning") == 1 {
iowarning = os.Stdout
} else {
iowarning = ioutil.Discard
}
if viper.GetInt("logging.error") == 1 {
ioerror = os.Stderr
} else {
ioerror = ioutil.Discard
}
if viper.GetInt("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))
}
ca.LogInit(iotrace, ioinfo, iowarning, ioerror, iopanic)
// cache configure
ca.CacheConfiguration()
ca.Info.Println("CA Server (" + viper.GetString("server.version") + ")")
aca := ca.NewACA()
defer aca.Stop()
eca := ca.NewECA()
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 {
panic(err)
}
opts = []grpc.ServerOption{grpc.Creds(creds)}
}
srv := grpc.NewServer(opts...)
aca.Start(srv)
eca.Start(srv)
tca.Start(srv)
tlsca.Start(srv)
if sock, err := net.Listen("tcp", viper.GetString("server.port")); err != nil {
ca.Error.Println("Fail to start CA Server: ", err)
os.Exit(1)
} else {
srv.Serve(sock)
sock.Close()
}
}
func main() {
// For environment variables.
viper.SetEnvPrefix(cmdRoot)
viper.AutomaticEnv()
replacer := strings.NewReplacer(".", "_")
viper.SetEnvKeyReplacer(replacer)
// Define command-line flags that are valid for all peer commands and
// subcommands.
mainFlags := mainCmd.PersistentFlags()
mainFlags.String("logging-level", "", "Default logging level and overrides, see core.yaml for full syntax")
viper.BindPFlag("logging_level", mainFlags.Lookup("logging-level"))
testCoverProfile := ""
mainFlags.StringVarP(&testCoverProfile, "test.coverprofile", "", "coverage.cov", "Done")
// Set the flags on the node start command.
flags := nodeStartCmd.Flags()
flags.BoolVarP(&chaincodeDevMode, "peer-chaincodedev", "", false, "Whether peer in chaincode development mode")
// Now set the configuration file.
viper.SetConfigName(cmdRoot) // Name of config file (without extension)
viper.AddConfigPath("./") // Path to look for the config file in
// Path to look for the config file in based on GOPATH
gopath := os.Getenv("GOPATH")
for _, p := range filepath.SplitList(gopath) {
peerpath := filepath.Join(p, "src/github.com/hyperledger/fabric/peer")
viper.AddConfigPath(peerpath)
}
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))
}
nodeCmd.AddCommand(nodeStartCmd)
nodeCmd.AddCommand(nodeStatusCmd)
nodeStopCmd.Flags().StringVar(&stopPidFile, "stop-peer-pid-file", viper.GetString("peer.fileSystemPath"), "Location of peer pid local file, for forces kill")
nodeCmd.AddCommand(nodeStopCmd)
mainCmd.AddCommand(nodeCmd)
// Set the flags on the login command.
networkLoginCmd.PersistentFlags().StringVarP(&loginPW, "password", "p", undefinedParamValue, "The password for user. You will be requested to enter the password if this flag is not specified.")
networkCmd.AddCommand(networkLoginCmd)
// vmCmd.AddCommand(vmPrimeCmd)
// mainCmd.AddCommand(vmCmd)
networkCmd.AddCommand(networkListCmd)
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(&chaincodeAttributesJSON, "attributes", "a", "[]", fmt.Sprintf("User attributes 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"))
chaincodeCmd.PersistentFlags().StringVarP(&customIDGenAlg, "tid", "t", undefinedParamValue, fmt.Sprintf("Name of a custom ID generation algorithm (hashing and decoding) e.g. sha256base64"))
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)
runtime.GOMAXPROCS(viper.GetInt("peer.gomaxprocs"))
// Init the crypto layer
if err := crypto.Init(); err != nil {
panic(fmt.Errorf("Failed to initialize 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)
}
logger.Info("Exiting.....")
}
func main() {
rootCmd := &cobra.Command{
Use: "mantl-api",
Short: "runs the mantl-api",
Run: func(cmd *cobra.Command, args []string) {
start()
},
PersistentPreRun: func(cmd *cobra.Command, args []string) {
readConfigFile()
setupLogging()
},
}
rootCmd.PersistentFlags().String("config-file", "", "The path to a (optional) configuration file")
rootCmd.PersistentFlags().String("consul-acl-token", "", "Consul ACL token for accessing mantl-install/apps path")
rootCmd.PersistentFlags().Bool("consul-no-verify-ssl", false, "Disable Consul SSL verification")
rootCmd.PersistentFlags().Int("consul-refresh-interval", 10, "The number of seconds after which to check consul for package requests")
rootCmd.PersistentFlags().String("consul", "http://localhost:8500", "Consul API address")
rootCmd.PersistentFlags().Bool("force-sync", false, "Force a synchronization of respository all sources at startup")
rootCmd.PersistentFlags().String("listen", ":4001", "listen for connections on this address")
rootCmd.PersistentFlags().String("log-format", "text", "specify output (text or json)")
rootCmd.PersistentFlags().String("log-level", "info", "one of debug, info, warn, error, or fatal")
rootCmd.PersistentFlags().String("marathon", "", "Marathon API address")
rootCmd.PersistentFlags().Bool("marathon-no-verify-ssl", false, "Disable Marathon SSL verification")
rootCmd.PersistentFlags().String("marathon-password", "", "Marathon API password")
rootCmd.PersistentFlags().String("marathon-user", "", "Marathon API user")
rootCmd.PersistentFlags().String("mesos", "", "Mesos API address")
rootCmd.PersistentFlags().Bool("mesos-no-verify-ssl", false, "Disable Mesos SSL verification")
rootCmd.PersistentFlags().String("mesos-principal", "", "Mesos principal for framework authentication")
rootCmd.PersistentFlags().String("mesos-secret", "", "Deprecated. Use mesos-secret-path instead")
rootCmd.PersistentFlags().String("mesos-secret-path", "/etc/sysconfig/mantl-api", "Path to a file on host sytem that contains the mesos secret for framework authentication")
rootCmd.PersistentFlags().String("vault-cubbyhole-token", "", "token for retrieving token from vault")
rootCmd.PersistentFlags().String("vault-token", "", "token for retrieving secrets from vault")
rootCmd.PersistentFlags().String("zookeeper", "", "Comma-delimited list of zookeeper servers")
for _, flags := range []*pflag.FlagSet{rootCmd.PersistentFlags()} {
err := viper.BindPFlags(flags)
if err != nil {
log.WithField("error", err).Fatal("could not bind flags")
}
}
viper.SetEnvPrefix("mantl_api")
viper.SetEnvKeyReplacer(strings.NewReplacer("-", "_"))
viper.AutomaticEnv()
syncCommand := &cobra.Command{
Use: "sync",
Short: "Synchronize universe repositories",
Long: "Forces a synchronization of all configured sources",
Run: func(cmd *cobra.Command, args []string) {
syncRepo(nil, true)
},
}
rootCmd.AddCommand(syncCommand)
versionCommand := &cobra.Command{
Use: "version",
Short: fmt.Sprintf("Print the version number of %s", Name),
Run: func(cmd *cobra.Command, args []string) {
fmt.Printf("%s v%s\n", Name, Version)
},
}
rootCmd.AddCommand(versionCommand)
rootCmd.Execute()
}