// Init initializes the crypto layer. It load from viper the security level
// and the logging setting.
func Init() (err error) {
// Init security level
securityLevel := 256
if viper.IsSet("security.level") {
ovveride := viper.GetInt("security.level")
if ovveride != 0 {
securityLevel = ovveride
}
}
hashAlgorithm := "SHA3"
if viper.IsSet("security.hashAlgorithm") {
ovveride := viper.GetString("security.hashAlgorithm")
if ovveride != "" {
hashAlgorithm = ovveride
}
}
log.Debugf("Working at security level [%d]", securityLevel)
if err = primitives.InitSecurityLevel(hashAlgorithm, securityLevel); err != nil {
log.Errorf("Failed setting security level: [%s]", err)
return
}
return
}
func parseDefaultPygmentsOpts() (map[string]string, error) {
options := make(map[string]string)
err := parseOptions(options, viper.GetString("PygmentsOptions"))
if err != nil {
return nil, err
}
if viper.IsSet("PygmentsStyle") {
options["style"] = viper.GetString("PygmentsStyle")
}
if viper.IsSet("PygmentsUseClasses") {
if viper.GetBool("PygmentsUseClasses") {
options["noclasses"] = "false"
} else {
options["noclasses"] = "true"
}
}
if _, ok := options["encoding"]; !ok {
options["encoding"] = "utf8"
}
return options, nil
}
func getLdflags(info ProjectInfo) string {
if viper.IsSet("build.ldflags") {
var (
tmplOutput = new(bytes.Buffer)
fnMap = template.FuncMap{
"date": time.Now().UTC().Format,
"host": os.Hostname,
"user": UserFunc,
"goversion": runtime.Version,
"repoPath": RepoPathFunc,
}
ldflags = viper.GetString("build.ldflags")
)
tmpl, err := template.New("ldflags").Funcs(fnMap).Parse(ldflags)
fatalMsg(err, "Failed to parse ldflags text/template :")
err = tmpl.Execute(tmplOutput, info)
fatalMsg(err, "Failed to execute ldflags text/template :")
if goos != "darwin" {
tmplOutput.WriteString("-extldflags \"-static\"")
}
return tmplOutput.String()
}
return fmt.Sprintf("-X main.Version %s", info.Version)
}
func watch() {
if !viper.IsSet("raven_dev") {
log.Fatal("Please specify a Raven device to connect to")
}
raven, err := goraven.Connect(viper.GetString("raven_dev"))
if err != nil {
log.Fatal(err)
}
defer raven.Close()
for {
notify, err := raven.Receive()
if err != nil {
log.Println(err)
}
switch t := notify.(type) {
case *goraven.ConnectionStatus:
log.Printf("Connection Status: %s", t.Status)
case *goraven.CurrentSummationDelivered:
pushCurrentSummationDelivered(t)
case *goraven.InstantaneousDemand:
pushInstantaneousDemand(t)
default:
}
}
}
// Init initializes the crypto layer. It load from viper the security level
// and the logging setting.
func Init() (err error) {
// Init log
log.ExtraCalldepth++
level, err := logging.LogLevel(viper.GetString("logging.crypto"))
if err == nil {
// No error, use the setting
logging.SetLevel(level, "crypto")
log.Info("Log level recognized '%s', set to %s", viper.GetString("logging.crypto"),
logging.GetLevel("crypto"))
} else {
log.Warning("Log level not recognized '%s', defaulting to %s: %s", viper.GetString("logging.crypto"),
logging.GetLevel("crypto"), err)
}
// Init security level
securityLevel := 256
if viper.IsSet("security.level") {
ovveride := viper.GetInt("security.level")
if ovveride != 0 {
securityLevel = ovveride
}
}
log.Debug("Working at security level [%d]", securityLevel)
if err = conf.InitSecurityLevel(securityLevel); err != nil {
log.Debug("Failed setting security level: [%s]", err)
return
}
return
}
func (m *conduitServerService) Execute(args []string, r <-chan svc.ChangeRequest, changes chan<- svc.Status) (ssec bool, errno uint32) {
const cmdsAccepted = svc.AcceptStop | svc.AcceptShutdown | svc.AcceptPauseAndContinue
changes <- svc.Status{State: svc.StartPending}
changes <- svc.Status{State: svc.Running, Accepts: cmdsAccepted}
if viper.IsSet("enable_long_polling") {
server.EnableLongPolling = viper.GetBool("enable_long_polling")
}
err := server.Start(viper.GetString("host"))
fmt.Println("Could not start server:", err)
loop:
for {
select {
case c := <-r:
switch c.Cmd {
case svc.Interrogate:
changes <- c.CurrentStatus
time.Sleep(100 * time.Millisecond)
changes <- c.CurrentStatus
case svc.Stop, svc.Shutdown:
break loop
default:
}
}
}
changes <- svc.Status{State: svc.StopPending}
return
}
// overwriteFlagsWithViperConfig finds and writes values to flags using viper as input.
func overwriteFlagsWithViperConfig() {
viperFlagSetter := func(f *flag.Flag) {
if viper.IsSet(f.Name) {
f.Value.Set(viper.GetString(f.Name))
}
}
flag.VisitAll(viperFlagSetter)
}
func validityPeriodUpdateEnabled() bool {
// If the update of the validity period is enabled in the configuration file return the configured value
if viper.IsSet("pki.validity-period.update") {
return viper.GetBool("pki.validity-period.update")
}
// Validity period update is enabled by default if no configuration was specified.
return true
}
func validityPeriodVerificationEnabled() bool {
// If the verification of the validity period is enabled in the configuration file return the configured value
if viper.IsSet("peer.validator.validity-period.verification") {
return viper.GetBool("peer.validator.validity-period.verification")
}
// Validity period verification is enabled by default if no configuration was specified.
return true
}
func deploySystemChaincodeEnabled() bool {
// If the deployment of system chaincode is enabled in the configuration file return the configured value
if viper.IsSet("ledger.blockchain.deploy-system-chaincode") {
return viper.GetBool("ledger.blockchain.deploy-system-chaincode")
}
// Deployment of system chaincode is enabled by default if no configuration was specified.
return true
}
//TestViper try to use viper
func TestViper() {
viper.AddConfigPath("/home/xiaoju/goworkspace/goplayground/")
viper.SetConfigName("test")
viper.SetConfigType("toml")
err := viper.ReadInConfig()
if err != nil {
fmt.Println("read viper configure", err)
}
//
var x int
if viper.IsSet("logger.meta.other.xo") {
x = viper.GetInt("logger.meta.other.xo")
} else {
x = 8
}
if viper.IsSet("logger.meta.input") {
metaInput := viper.GetStringMap("logger.meta.input")
for k, v := range metaInput {
// if viper.IsSet("logger.meta.input." + k) {
// kv := viper.GetStringMapString("logger.meta.input." + k)
// for x, y := range kv {
// fmt.Println(x, y)
// }
// }
fmt.Println(k, v)
if value, ok := v.(map[string]string); ok {
for x, y := range value {
fmt.Println(x, y)
}
} else {
fmt.Println(ok)
}
}
}
// for k, v := range logConf["meta"]["input"] {
// fmt.Println(k, v)
// }
fmt.Println(x)
}
func NewApp(cnfFileName string) *App {
log.Printf("httpapi init, read config from: %s\n", cnfFileName)
app := &App{}
app.router = echo.New()
app.router.Use(middleware.Logger(), middleware.Recover())
app.router.Use(echoJsonCheckErrorMW())
app.router.Get("/vms", app.handleListVm)
app.router.Post("/vms/:alias", app.handleDownloadVm)
viper.SetConfigFile(cnfFileName)
err := viper.ReadInConfig()
//if config file exists and configs have been read successfully
if err == nil {
for _, cnfAlias := range []string{
"GOVC_URL",
"GOVC_USERNAME",
"GOVC_PASSWORD",
"GOVC_CERTIFICATE",
"GOVC_PRIVATE_KEY",
"GOVC_INSECURE",
"GOVC_PERSIST_SESSION",
"GOVC_MIN_API_VERSION",
} {
//rewrite only if not set in env scope
if viper.IsSet(cnfAlias) && os.Getenv(cnfAlias) == "" {
//log.Printf("write to env: %s=%s\n", cnfAlias, viper.GetString(cnfAlias))
os.Setenv(cnfAlias, viper.GetString(cnfAlias))
}
}
if viper.IsSet("vm-path") {
app.vmPath = viper.GetString("vm-path")
//log.Printf("vm path for host: %s\n", app.vmPath)
}
} else {
log.Fatalf("%s\nThis application need config.json with vm-path key and path to VM on host machine\n", err)
}
return app
}
// InitializeConfig loads our configuration using Viper package.
func InitializeConfig() {
// Set config file
viper.SetConfigName("config")
// Add config path
viper.AddConfigPath("$HOME/.sharptv")
// Read in the config
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))
}
// Load default settings
viper.SetDefault("debug", false)
viper.SetEnvPrefix("gosharptv") // will be uppercased automatically
viper.BindEnv("debug")
viper.BindEnv("ip")
viper.BindEnv("port")
// Do some flag handling and any complicated config logic
if !viper.IsSet("ip") || !viper.IsSet("port") {
fmt.Println("Configuration error. Both IP and PORT must be set via either config, environment, or flags.")
os.Exit(1)
}
// TODO --implement the use of this data in the input command
inputLabelMap = make(map[string]int)
inputNames := []string{"input1", "input2", "input3", "input4", "input5", "input6", "input7", "input8"}
for i, v := range inputNames {
if viper.IsSet(v) {
inputname := viper.GetString(v)
inputLabelMap[inputname] = i + 1
}
}
}
func whichLicense() string {
// if explicitly flagged, use that
if userLicense != "" {
return matchLicense(userLicense)
}
// if already present in the project, use that
// TODO: Inspect project for existing license
// default to viper's setting
if viper.IsSet("license.header") || viper.IsSet("license.text") {
if custom, ok := Licenses["custom"]; ok {
custom.Header = viper.GetString("license.header")
custom.Text = viper.GetString("license.text")
Licenses["custom"] = custom
return "custom"
}
}
return matchLicense(viper.GetString("license"))
}
func setupLogging() {
logLevel, ok := logger.LevelMatches[strings.ToUpper(viper.GetString("log_level"))]
if !ok {
logLevel = logger.LevelInfo
}
logger.SetLogThreshold(logLevel)
logger.SetStdoutThreshold(logLevel)
if viper.IsSet("log_file") && viper.GetString("log_file") != "" {
logger.SetLogFile(viper.GetString("log_file"))
// do not log into stdout when log file provided
logger.SetStdoutThreshold(logger.LevelNone)
}
}
func loadConfigs() {
genesisLogger.Info("Loading configurations...")
genesis = viper.GetStringMap("ledger.blockchain.genesisBlock")
mode = viper.GetString("chaincode.chaincoderunmode")
genesisLogger.Info("Configurations loaded: genesis=%s, mode=[%s], deploySystemChaincodeEnabled=[%t]",
genesis, mode, deploySystemChaincodeEnabled)
if viper.IsSet("ledger.blockchain.deploy-system-chaincode") {
// If the deployment of system chaincode is enabled in the configuration file return the configured value
deploySystemChaincodeEnabled = viper.GetBool("ledger.blockchain.deploy-system-chaincode")
} else {
// Deployment of system chaincode is enabled by default if no configuration was specified.
deploySystemChaincodeEnabled = true
}
}
func getGlobalProject(v *viper.Viper) (*libcentrifugo.Project, bool) {
p := &libcentrifugo.Project{}
// TODO: the same as for structureFromConfig function
if v == nil {
if !viper.IsSet("project_name") || viper.GetString("project_name") == "" {
return nil, false
}
p.Name = libcentrifugo.ProjectKey(viper.GetString("project_name"))
p.Secret = viper.GetString("project_secret")
p.ConnLifetime = int64(viper.GetInt("project_connection_lifetime"))
p.Anonymous = viper.GetBool("project_anonymous")
p.Watch = viper.GetBool("project_watch")
p.Publish = viper.GetBool("project_publish")
p.JoinLeave = viper.GetBool("project_join_leave")
p.Presence = viper.GetBool("project_presence")
p.HistorySize = int64(viper.GetInt("project_history_size"))
p.HistoryLifetime = int64(viper.GetInt("project_history_lifetime"))
} else {
if !v.IsSet("project_name") || v.GetString("project_name") == "" {
return nil, false
}
p.Name = libcentrifugo.ProjectKey(v.GetString("project_name"))
p.Secret = v.GetString("project_secret")
p.ConnLifetime = int64(v.GetInt("project_connection_lifetime"))
p.Anonymous = v.GetBool("project_anonymous")
p.Watch = v.GetBool("project_watch")
p.Publish = v.GetBool("project_publish")
p.JoinLeave = v.GetBool("project_join_leave")
p.Presence = v.GetBool("project_presence")
p.HistorySize = int64(v.GetInt("project_history_size"))
p.HistoryLifetime = int64(v.GetInt("project_history_lifetime"))
}
var nl []libcentrifugo.Namespace
if v == nil {
viper.MarshalKey("project_namespaces", &nl)
} else {
v.MarshalKey("project_namespaces", &nl)
}
p.Namespaces = nl
return p, true
}
func (conf *configuration) init() error {
conf.configurationPathProperty = "peer.fileSystemPath"
conf.ecaPAddressProperty = "peer.pki.eca.paddr"
conf.tcaPAddressProperty = "peer.pki.tca.paddr"
conf.tlscaPAddressProperty = "peer.pki.tlsca.paddr"
// Check mandatory fields
if err := conf.checkProperty(conf.configurationPathProperty); err != nil {
return err
}
if err := conf.checkProperty(conf.ecaPAddressProperty); err != nil {
return err
}
if err := conf.checkProperty(conf.tcaPAddressProperty); err != nil {
return err
}
if err := conf.checkProperty(conf.tlscaPAddressProperty); err != nil {
return err
}
// Set configuration path
conf.configurationPath = filepath.Join(
viper.GetString(conf.configurationPathProperty),
"crypto", conf.prefix, conf.name,
)
// Set ks path
conf.keystorePath = filepath.Join(conf.configurationPath, "ks")
// Set raws path
conf.rawsPath = filepath.Join(conf.keystorePath, "raw")
// Set TLS host override
conf.tlsServerName = "tlsca"
if viper.IsSet("peer.pki.tls.server-host-override") {
ovveride := viper.GetString("peer.pki.tls.server-host-override")
if ovveride != "" {
conf.tlsServerName = ovveride
}
}
return nil
}
func init() {
viper.SetDefault("port", 8080)
viper.SetDefault("min_passwd_len", 8)
viper.SetDefault("pgp_sign", false)
viper.SetDefault("smtp_host", "localhost")
viper.SetDefault("smtp_port", 25)
viper.SetDefault("email_link_base", "http://localhost")
viper.SetDefault("email_from", "*****@*****.**")
viper.SetDefault("email_prefix", "mokey")
viper.SetDefault("setup_max_age", 86400)
viper.SetDefault("reset_max_age", 3600)
viper.SetDefault("max_attempts", 10)
viper.SetDefault("bind", "")
viper.SetDefault("secret_key", "change-me")
viper.SetDefault("driver", "mysql")
viper.SetDefault("dsn", "/mokey?parseTime=true")
viper.SetDefault("rate_limit", false)
viper.SetDefault("redis", ":6379")
viper.SetDefault("max_requests", 15)
viper.SetDefault("rate_limit_expire", 3600)
gob.Register(&ipa.UserRecord{})
gob.Register(&ipa.IpaDateTime{})
if !viper.IsSet("ipahost") {
cfg, err := ini.Load("/etc/ipa/default.conf")
if err != nil {
viper.SetDefault("ipahost", "localhost")
return
}
ipaServer, err := cfg.Section("global").GetKey("server")
if err != nil {
viper.SetDefault("ipahost", "localhost")
return
}
viper.SetDefault("ipahost", ipaServer)
}
}
func configureTargets() io.Writer {
if viper.IsSet("log.targets") {
var (
writers []io.Writer
logTargets []logTarget
)
if err := mapstructure.Decode(viper.Get("log.targets"), &logTargets); err != nil {
panic(fmt.Errorf("Failed to process log targets: %s", err))
}
for _, target := range logTargets {
switch target.Type {
case "os":
if target.Target == "stdout" {
writers = append(writers, output.Stdout())
} else if target.Target == "stderr" {
writers = append(writers, output.Stderr())
}
case "file":
file, err := os.OpenFile(target.Target, os.O_APPEND|os.O_WRONLY, os.ModeAppend)
if err != nil {
if os.IsNotExist(err) {
file, err = os.Create(target.Target)
if err != nil {
panic(fmt.Errorf("Failed creating a file log target: %s", err))
}
} else {
panic(err)
}
}
writers = append(writers, file)
}
}
return io.MultiWriter(writers...)
}
return output.Stdout()
}
func (f Funcs) CallFactory(keyPrefix string, namespace string, defaultFactory string) *reflect.Value { //, error) {
key := fmt.Sprintf("%s.%s.factory", keyPrefix, namespace)
var factory string
if !viper.IsSet(key) {
//TODO: warn
println("key is not set: ", key)
factory = defaultFactory
} else {
println("key is set: ", key)
factory = viper.GetString(key)
}
fmt.Printf("factory '%s'\n", factory)
results, err := f.Call(factory)
fmt.Errorf("error in CallFactory. key: %s, factory: %s\n%s", key, factory, err) //TODO deal with err
if len(results) != 1 {
return nil //, errors.New("Wrong number of loadbalancer results " + strconv.Itoa(len(results)))
}
result := results[0]
return &result
}
// Enable viper configuration management of flags.
func ViperizeFlags() {
// Add viper in a minimal way.
// Flag interop isnt possible, since 'go test' coupling to flag.Parse.
viper.SetConfigName("e2e")
viper.AddConfigPath(".")
viper.ReadInConfig()
// TODO @jayunit100: Maybe a more elegant viper-flag integration for the future?
// For now, we layer it on top, because 'flag' deps of 'go test' make pflag wrappers
// fragile, seeming to force 'flag' to have deep awareness of pflag params.
RegisterCommonFlags()
RegisterClusterFlags()
flag.Parse()
viperFlagSetter := func(f *flag.Flag) {
if viper.IsSet(f.Name) {
glog.V(4).Infof("[viper config] Overwriting, found a settting for %v %v", f.Name, f.Value)
f.Value.Set(viper.GetString(f.Name))
}
}
// Each flag that we've declared can be set via viper.
flag.VisitAll(viperFlagSetter)
}
/*
* POST /projects
*/
func PostProjects(w http.ResponseWriter, r *http.Request) {
var project models.ProjectRequest
//Extract github repo url
body, err := ioutil.ReadAll(io.LimitReader(r.Body, 1048576))
if err != nil {
panic(err)
}
if err := r.Body.Close(); err != nil {
panic(err)
}
if err := json.Unmarshal(body, &project); err != nil {
w.Header().Set("Content-Type", "application/json; charset=UTF-8")
w.WriteHeader(422) // unprocessable entity
if err := json.NewEncoder(w).Encode(err); err != nil {
panic(err)
}
}
log.Println("Creating a docker")
//local docker
var dockerClient *externals.DockerInteractor
if viper.IsSet("dockerRemote") {
dockerClient = externals.NewRemoteInteractor(viper.GetString("dockerRemote.ip"), viper.GetString("dockerRemote.port"))
} else {
dockerClient = externals.NewLocalInteractor("unix:///var/run/docker.sock")
}
config := externals.Config{
User: "******",
Project: "project1",
}
dockerClient.RunContainer(config)
log.Println("Retrieving github " + project.Github + " from docker")
//Call inside the executed docker the set up server
fmt.Fprintln(w, "ok")
}
// InitializeConfig initializes a config file with sensible default configuration flags.
func InitializeConfig() {
viper.SetConfigFile(CfgFile)
viper.AddConfigPath(Source)
err := viper.ReadInConfig()
if err != nil {
jww.ERROR.Println("Unable to locate Config file. Perhaps you need to create a new site. Run `hugo help new` for details")
}
viper.RegisterAlias("indexes", "taxonomies")
LoadDefaultSettings()
if hugoCmdV.PersistentFlags().Lookup("buildDrafts").Changed {
viper.Set("BuildDrafts", Draft)
}
if hugoCmdV.PersistentFlags().Lookup("buildFuture").Changed {
viper.Set("BuildFuture", Future)
}
if hugoCmdV.PersistentFlags().Lookup("uglyUrls").Changed {
viper.Set("UglyURLs", UglyURLs)
}
if hugoCmdV.PersistentFlags().Lookup("disableRSS").Changed {
viper.Set("DisableRSS", DisableRSS)
}
if hugoCmdV.PersistentFlags().Lookup("disableSitemap").Changed {
viper.Set("DisableSitemap", DisableSitemap)
}
if hugoCmdV.PersistentFlags().Lookup("verbose").Changed {
viper.Set("Verbose", Verbose)
}
if hugoCmdV.PersistentFlags().Lookup("pluralizeListTitles").Changed {
viper.Set("PluralizeListTitles", PluralizeListTitles)
}
if hugoCmdV.PersistentFlags().Lookup("preserveTaxonomyNames").Changed {
viper.Set("PreserveTaxonomyNames", PreserveTaxonomyNames)
}
if hugoCmdV.PersistentFlags().Lookup("editor").Changed {
viper.Set("NewContentEditor", Editor)
}
if hugoCmdV.PersistentFlags().Lookup("logFile").Changed {
viper.Set("LogFile", LogFile)
}
if BaseURL != "" {
if !strings.HasSuffix(BaseURL, "/") {
BaseURL = BaseURL + "/"
}
viper.Set("BaseURL", BaseURL)
}
if !viper.GetBool("RelativeURLs") && viper.GetString("BaseURL") == "" {
jww.ERROR.Println("No 'baseurl' set in configuration or as a flag. Features like page menus will not work without one.")
}
if Theme != "" {
viper.Set("theme", Theme)
}
if Destination != "" {
viper.Set("PublishDir", Destination)
}
if Source != "" {
viper.Set("WorkingDir", Source)
} else {
dir, _ := os.Getwd()
viper.Set("WorkingDir", dir)
}
if hugoCmdV.PersistentFlags().Lookup("ignoreCache").Changed {
viper.Set("IgnoreCache", IgnoreCache)
}
if CacheDir != "" {
if helpers.FilePathSeparator != CacheDir[len(CacheDir)-1:] {
CacheDir = CacheDir + helpers.FilePathSeparator
}
isDir, err := helpers.DirExists(CacheDir, hugofs.SourceFs)
utils.CheckErr(err)
if isDir == false {
mkdir(CacheDir)
}
viper.Set("CacheDir", CacheDir)
} else {
viper.Set("CacheDir", helpers.GetTempDir("hugo_cache", hugofs.SourceFs))
}
if VerboseLog || Logging || (viper.IsSet("LogFile") && viper.GetString("LogFile") != "") {
if viper.IsSet("LogFile") && viper.GetString("LogFile") != "" {
jww.SetLogFile(viper.GetString("LogFile"))
} else {
jww.UseTempLogFile("hugo")
}
} else {
jww.DiscardLogging()
}
if viper.GetBool("verbose") {
jww.SetStdoutThreshold(jww.LevelInfo)
}
if VerboseLog {
jww.SetLogThreshold(jww.LevelInfo)
}
jww.INFO.Println("Using config file:", viper.ConfigFileUsed())
themeDir := helpers.GetThemeDir()
if themeDir != "" {
if _, err := os.Stat(themeDir); os.IsNotExist(err) {
jww.FATAL.Fatalln("Unable to find theme Directory:", themeDir)
}
}
themeVersionMismatch, minVersion := helpers.IsThemeVsHugoVersionMismatch()
if themeVersionMismatch {
jww.ERROR.Printf("Current theme does not support Hugo version %s. Minimum version required is %s\n",
helpers.HugoReleaseVersion(), minVersion)
}
}
func mainCommand(cmd *cobra.Command, args []string) {
err := viper.Unmarshal(&c)
if err != nil {
log.Fatalf("Unable to marshal configuration: %v", err)
}
if !viper.IsSet("dbpath") {
log.Fatalf("Please set the dbpath configuration option or EVEINDY_DBPATH " +
"environment variable to the database's path.")
}
if !(viper.IsSet("CookieDomain") && viper.IsSet("CookiePath")) {
log.Fatalf("Please set the CookieDomain and CookiePath configuration options.")
}
if !(viper.IsSet("ClientID") && viper.IsSet("ClientSecret") &&
viper.IsSet("RedirectURL")) {
log.Fatalf("Please set the ClientID, ClientSecret, and RedirectURL configuration " +
"options as registered with CCP.")
}
// workaround for viper bug
// c.Dev = viper.GetBool("Dev")
sde := dbaccess.SQLDatabase(c.DbDriver, c.DbPath)
var myCache evego.Cache
switch c.Cache {
case "inproc":
myCache = server.InMemCache()
case "redis":
if c.RedisPassword != "" {
myCache = cache.RedisCache(c.RedisHost, c.RedisPassword)
} else {
myCache = cache.RedisCache(c.RedisHost)
}
default:
log.Fatalf(
"The Cache configuration option must be set to \"inproc\" (default) or \"redis\".")
}
xmlAPI := eveapi.XML(c.XMLAPIEndpoint, sde, myCache)
localdb, err := db.Interface(c.DbDriver, c.DbPath, xmlAPI)
if err != nil {
log.Fatalf("Unable to connect to local database: %v", err)
}
var router evego.Router
switch c.Router {
case "evecentral":
router = routing.EveCentralRouter(
"http://api.eve-central.com/api/route", myCache)
case "sql":
router = routing.SQLRouter(c.DbDriver, c.DbPath, myCache)
default:
log.Fatalf(
"The Router configuration option must be set to \"evecentral\" (default) or \"sql\".")
}
eveCentralMarket := market.EveCentral(sde, router, xmlAPI,
"http://api.eve-central.com/api/quicklook", myCache)
sessionizer := server.GetSessionizer(c.CookieDomain, c.CookiePath, !c.Dev, localdb)
mux := newMux()
setRoutes(mux, sde, localdb, xmlAPI, eveCentralMarket, sessionizer, myCache)
// Set up internal bits.
// Start background jobs.
server.StartJobs(localdb)
serve(mux, c.BindProtocol, c.Bind)
}
// InitializeConfig initializes a config file with sensible default configuration flags.
func InitializeConfig(subCmdVs ...*cobra.Command) error {
if err := hugolib.LoadGlobalConfig(source, cfgFile); err != nil {
return err
}
for _, cmdV := range append([]*cobra.Command{hugoCmdV}, subCmdVs...) {
if flagChanged(cmdV.PersistentFlags(), "verbose") {
viper.Set("verbose", verbose)
}
if flagChanged(cmdV.PersistentFlags(), "logFile") {
viper.Set("logFile", logFile)
}
if flagChanged(cmdV.Flags(), "cleanDestinationDir") {
viper.Set("cleanDestinationDir", cleanDestination)
}
if flagChanged(cmdV.Flags(), "buildDrafts") {
viper.Set("buildDrafts", draft)
}
if flagChanged(cmdV.Flags(), "buildFuture") {
viper.Set("buildFuture", future)
}
if flagChanged(cmdV.Flags(), "buildExpired") {
viper.Set("buildExpired", expired)
}
if flagChanged(cmdV.Flags(), "uglyURLs") {
viper.Set("uglyURLs", uglyURLs)
}
if flagChanged(cmdV.Flags(), "canonifyURLs") {
viper.Set("canonifyURLs", canonifyURLs)
}
if flagChanged(cmdV.Flags(), "disable404") {
viper.Set("disable404", disable404)
}
if flagChanged(cmdV.Flags(), "disableRSS") {
viper.Set("disableRSS", disableRSS)
}
if flagChanged(cmdV.Flags(), "disableSitemap") {
viper.Set("disableSitemap", disableSitemap)
}
if flagChanged(cmdV.Flags(), "enableRobotsTXT") {
viper.Set("enableRobotsTXT", enableRobotsTXT)
}
if flagChanged(cmdV.Flags(), "pluralizeListTitles") {
viper.Set("pluralizeListTitles", pluralizeListTitles)
}
if flagChanged(cmdV.Flags(), "preserveTaxonomyNames") {
viper.Set("preserveTaxonomyNames", preserveTaxonomyNames)
}
if flagChanged(cmdV.Flags(), "ignoreCache") {
viper.Set("ignoreCache", ignoreCache)
}
if flagChanged(cmdV.Flags(), "forceSyncStatic") {
viper.Set("forceSyncStatic", forceSync)
}
if flagChanged(cmdV.Flags(), "noTimes") {
viper.Set("noTimes", noTimes)
}
}
if baseURL != "" {
if !strings.HasSuffix(baseURL, "/") {
baseURL = baseURL + "/"
}
viper.Set("baseURL", baseURL)
}
if !viper.GetBool("relativeURLs") && viper.GetString("baseURL") == "" {
jww.ERROR.Println("No 'baseurl' set in configuration or as a flag. Features like page menus will not work without one.")
}
if theme != "" {
viper.Set("theme", theme)
}
if destination != "" {
viper.Set("publishDir", destination)
}
var dir string
if source != "" {
dir, _ = filepath.Abs(source)
} else {
dir, _ = os.Getwd()
}
viper.Set("workingDir", dir)
if contentDir != "" {
viper.Set("contentDir", contentDir)
}
if layoutDir != "" {
viper.Set("layoutDir", layoutDir)
}
if cacheDir != "" {
viper.Set("cacheDir", cacheDir)
}
cacheDir = viper.GetString("cacheDir")
if cacheDir != "" {
if helpers.FilePathSeparator != cacheDir[len(cacheDir)-1:] {
cacheDir = cacheDir + helpers.FilePathSeparator
}
isDir, err := helpers.DirExists(cacheDir, hugofs.Source())
utils.CheckErr(err)
if isDir == false {
mkdir(cacheDir)
}
viper.Set("cacheDir", cacheDir)
} else {
viper.Set("cacheDir", helpers.GetTempDir("hugo_cache", hugofs.Source()))
}
if verboseLog || logging || (viper.IsSet("logFile") && viper.GetString("logFile") != "") {
if viper.IsSet("logFile") && viper.GetString("logFile") != "" {
jww.SetLogFile(viper.GetString("logFile"))
} else {
jww.UseTempLogFile("hugo")
}
} else {
jww.DiscardLogging()
}
if quiet {
jww.SetStdoutThreshold(jww.LevelError)
} else if viper.GetBool("verbose") {
jww.SetStdoutThreshold(jww.LevelInfo)
}
if verboseLog {
jww.SetLogThreshold(jww.LevelInfo)
}
jww.INFO.Println("Using config file:", viper.ConfigFileUsed())
// Init file systems. This may be changed at a later point.
hugofs.InitDefaultFs()
themeDir := helpers.GetThemeDir()
if themeDir != "" {
if _, err := hugofs.Source().Stat(themeDir); os.IsNotExist(err) {
return newSystemError("Unable to find theme Directory:", themeDir)
}
}
themeVersionMismatch, minVersion := isThemeVsHugoVersionMismatch()
if themeVersionMismatch {
jww.ERROR.Printf("Current theme does not support Hugo version %s. Minimum version required is %s\n",
helpers.HugoReleaseVersion(), minVersion)
}
return nil
}
// InitializeConfig initializes a config file with sensible default configuration flags.
func InitializeConfig() {
viper.SetConfigFile(CfgFile)
viper.AddConfigPath(Source)
err := viper.ReadInConfig()
if err != nil {
jww.ERROR.Println("Unable to locate Config file. Perhaps you need to create a new site. Run `hugo help new` for details")
}
viper.RegisterAlias("indexes", "taxonomies")
viper.SetDefault("Watch", false)
viper.SetDefault("MetaDataFormat", "toml")
viper.SetDefault("DisableRSS", false)
viper.SetDefault("DisableSitemap", false)
viper.SetDefault("ContentDir", "content")
viper.SetDefault("LayoutDir", "layouts")
viper.SetDefault("StaticDir", "static")
viper.SetDefault("ArchetypeDir", "archetypes")
viper.SetDefault("PublishDir", "public")
viper.SetDefault("DataDir", "data")
viper.SetDefault("DefaultLayout", "post")
viper.SetDefault("BuildDrafts", false)
viper.SetDefault("BuildFuture", false)
viper.SetDefault("UglyURLs", false)
viper.SetDefault("Verbose", false)
viper.SetDefault("IgnoreCache", false)
viper.SetDefault("CanonifyURLs", false)
viper.SetDefault("Taxonomies", map[string]string{"tag": "tags", "category": "categories"})
viper.SetDefault("Permalinks", make(hugolib.PermalinkOverrides, 0))
viper.SetDefault("Sitemap", hugolib.Sitemap{Priority: -1})
viper.SetDefault("PygmentsStyle", "monokai")
viper.SetDefault("DefaultExtension", "html")
viper.SetDefault("PygmentsUseClasses", false)
viper.SetDefault("DisableLiveReload", false)
viper.SetDefault("PluralizeListTitles", true)
viper.SetDefault("FootnoteAnchorPrefix", "")
viper.SetDefault("FootnoteReturnLinkContents", "")
viper.SetDefault("NewContentEditor", "")
viper.SetDefault("Paginate", 10)
viper.SetDefault("PaginatePath", "page")
viper.SetDefault("Blackfriday", helpers.NewBlackfriday())
if hugoCmdV.PersistentFlags().Lookup("buildDrafts").Changed {
viper.Set("BuildDrafts", Draft)
}
if hugoCmdV.PersistentFlags().Lookup("buildFuture").Changed {
viper.Set("BuildFuture", Future)
}
if hugoCmdV.PersistentFlags().Lookup("uglyUrls").Changed {
viper.Set("UglyURLs", UglyURLs)
}
if hugoCmdV.PersistentFlags().Lookup("disableRSS").Changed {
viper.Set("DisableRSS", DisableRSS)
}
if hugoCmdV.PersistentFlags().Lookup("disableSitemap").Changed {
viper.Set("DisableSitemap", DisableSitemap)
}
if hugoCmdV.PersistentFlags().Lookup("verbose").Changed {
viper.Set("Verbose", Verbose)
}
if hugoCmdV.PersistentFlags().Lookup("pluralizeListTitles").Changed {
viper.Set("PluralizeListTitles", PluralizeListTitles)
}
if hugoCmdV.PersistentFlags().Lookup("editor").Changed {
viper.Set("NewContentEditor", Editor)
}
if hugoCmdV.PersistentFlags().Lookup("logFile").Changed {
viper.Set("LogFile", LogFile)
}
if BaseURL != "" {
if !strings.HasSuffix(BaseURL, "/") {
BaseURL = BaseURL + "/"
}
viper.Set("BaseURL", BaseURL)
}
if viper.GetString("BaseURL") == "" {
jww.ERROR.Println("No 'baseurl' set in configuration or as a flag. Features like page menus will not work without one.")
}
if Theme != "" {
viper.Set("theme", Theme)
}
if Destination != "" {
viper.Set("PublishDir", Destination)
}
if Source != "" {
viper.Set("WorkingDir", Source)
} else {
dir, _ := os.Getwd()
viper.Set("WorkingDir", dir)
}
if hugoCmdV.PersistentFlags().Lookup("ignoreCache").Changed {
viper.Set("IgnoreCache", IgnoreCache)
}
if CacheDir != "" {
if helpers.FilePathSeparator != CacheDir[len(CacheDir)-1:] {
CacheDir = CacheDir + helpers.FilePathSeparator
}
isDir, err := helpers.DirExists(CacheDir, hugofs.SourceFs)
utils.CheckErr(err)
if isDir == false {
mkdir(CacheDir)
}
viper.Set("CacheDir", CacheDir)
} else {
viper.Set("CacheDir", helpers.GetTempDir("hugo_cache", hugofs.SourceFs))
}
if VerboseLog || Logging || (viper.IsSet("LogFile") && viper.GetString("LogFile") != "") {
if viper.IsSet("LogFile") && viper.GetString("LogFile") != "" {
jww.SetLogFile(viper.GetString("LogFile"))
} else {
jww.UseTempLogFile("hugo")
}
} else {
jww.DiscardLogging()
}
if viper.GetBool("verbose") {
jww.SetStdoutThreshold(jww.LevelInfo)
}
if VerboseLog {
jww.SetLogThreshold(jww.LevelInfo)
}
jww.INFO.Println("Using config file:", viper.ConfigFileUsed())
}
func (conf *configuration) init() error {
conf.configurationPathProperty = "peer.fileSystemPath"
conf.ecaPAddressProperty = "peer.pki.eca.paddr"
conf.tcaPAddressProperty = "peer.pki.tca.paddr"
conf.tlscaPAddressProperty = "peer.pki.tlsca.paddr"
conf.logPrefix = "[" + conf.prefix + "." + conf.name + "] "
// Check mandatory fields
if err := conf.checkProperty(conf.configurationPathProperty); err != nil {
return err
}
if err := conf.checkProperty(conf.ecaPAddressProperty); err != nil {
return err
}
if err := conf.checkProperty(conf.tcaPAddressProperty); err != nil {
return err
}
if err := conf.checkProperty(conf.tlscaPAddressProperty); err != nil {
return err
}
conf.configurationPath = viper.GetString(conf.configurationPathProperty)
conf.rootDataPath = conf.configurationPath
// Set configuration path
conf.configurationPath = filepath.Join(
conf.configurationPath,
"crypto", conf.prefix, conf.name,
)
// Set ks path
conf.keystorePath = filepath.Join(conf.configurationPath, "ks")
// Set raws path
conf.rawsPath = filepath.Join(conf.keystorePath, "raw")
// Set tCerts path
conf.tCertsPath = filepath.Join(conf.keystorePath, "tcerts")
conf.securityLevel = 384
if viper.IsSet("security.level") {
ovveride := viper.GetInt("security.level")
if ovveride != 0 {
conf.securityLevel = ovveride
}
}
conf.hashAlgorithm = "SHA3"
if viper.IsSet("security.hashAlgorithm") {
ovveride := viper.GetString("security.hashAlgorithm")
if ovveride != "" {
conf.hashAlgorithm = ovveride
}
}
// Set TLS host override
conf.tlsServerName = "tlsca"
if viper.IsSet("peer.pki.tls.serverhostoverride") {
ovveride := viper.GetString("peer.pki.tls.serverhostoverride")
if ovveride != "" {
conf.tlsServerName = ovveride
}
}
// Set tCertBatchSize
conf.tCertBatchSize = 200
if viper.IsSet("security.tcert.batch.size") {
ovveride := viper.GetInt("security.tcert.batch.size")
if ovveride != 0 {
conf.tCertBatchSize = ovveride
}
}
// Set multithread
conf.multiThreading = false
if viper.IsSet("security.multithreading.enabled") {
conf.multiThreading = viper.GetBool("security.multithreading.enabled")
}
// Set attributes
conf.tCertAttributes = []*membersrvc.TCertAttribute{}
if viper.IsSet("security.tcert.attributes") {
attributes := viper.GetStringMapString("security.tcert.attributes")
for key, value := range attributes {
conf.tCertAttributes = append(conf.tCertAttributes, &membersrvc.TCertAttribute{key, value})
}
}
return nil
}
// InitializeConfig initializes a config file with sensible default configuration flags.
// A Hugo command that calls initCoreCommonFlags() can pass itself
// as an argument to have its command-line flags processed here.
func InitializeConfig(subCmdVs ...*cobra.Command) error {
viper.SetConfigFile(cfgFile)
// See https://github.com/spf13/viper/issues/73#issuecomment-126970794
if source == "" {
viper.AddConfigPath(".")
} else {
viper.AddConfigPath(source)
}
err := viper.ReadInConfig()
if err != nil {
if _, ok := err.(viper.ConfigParseError); ok {
return newSystemError(err)
} else {
return newSystemErrorF("Unable to locate Config file. Perhaps you need to create a new site.\n Run `hugo help new` for details. (%s)\n", err)
}
}
viper.RegisterAlias("indexes", "taxonomies")
LoadDefaultSettings()
for _, cmdV := range append([]*cobra.Command{hugoCmdV}, subCmdVs...) {
if flagChanged(cmdV.PersistentFlags(), "verbose") {
viper.Set("Verbose", verbose)
}
if flagChanged(cmdV.PersistentFlags(), "logFile") {
viper.Set("LogFile", logFile)
}
if flagChanged(cmdV.Flags(), "cleanDestinationDir") {
viper.Set("cleanDestinationDir", cleanDestination)
}
if flagChanged(cmdV.Flags(), "buildDrafts") {
viper.Set("BuildDrafts", draft)
}
if flagChanged(cmdV.Flags(), "buildFuture") {
viper.Set("BuildFuture", future)
}
if flagChanged(cmdV.Flags(), "uglyURLs") {
viper.Set("UglyURLs", uglyURLs)
}
if flagChanged(cmdV.Flags(), "canonifyURLs") {
viper.Set("CanonifyURLs", canonifyURLs)
}
if flagChanged(cmdV.Flags(), "disableRSS") {
viper.Set("DisableRSS", disableRSS)
}
if flagChanged(cmdV.Flags(), "disableSitemap") {
viper.Set("DisableSitemap", disableSitemap)
}
if flagChanged(cmdV.Flags(), "disableRobotsTXT") {
viper.Set("DisableRobotsTXT", disableRobotsTXT)
}
if flagChanged(cmdV.Flags(), "pluralizeListTitles") {
viper.Set("PluralizeListTitles", pluralizeListTitles)
}
if flagChanged(cmdV.Flags(), "preserveTaxonomyNames") {
viper.Set("PreserveTaxonomyNames", preserveTaxonomyNames)
}
if flagChanged(cmdV.Flags(), "ignoreCache") {
viper.Set("IgnoreCache", ignoreCache)
}
if flagChanged(cmdV.Flags(), "forceSyncStatic") {
viper.Set("ForceSyncStatic", forceSync)
}
if flagChanged(cmdV.Flags(), "noTimes") {
viper.Set("NoTimes", noTimes)
}
}
if baseURL != "" {
if !strings.HasSuffix(baseURL, "/") {
baseURL = baseURL + "/"
}
viper.Set("BaseURL", baseURL)
}
if !viper.GetBool("RelativeURLs") && viper.GetString("BaseURL") == "" {
jww.ERROR.Println("No 'baseurl' set in configuration or as a flag. Features like page menus will not work without one.")
}
if theme != "" {
viper.Set("theme", theme)
}
if destination != "" {
viper.Set("PublishDir", destination)
}
if source != "" {
dir, _ := filepath.Abs(source)
viper.Set("WorkingDir", dir)
} else {
dir, _ := os.Getwd()
viper.Set("WorkingDir", dir)
}
if contentDir != "" {
viper.Set("ContentDir", contentDir)
}
if layoutDir != "" {
viper.Set("LayoutDir", layoutDir)
}
if cacheDir != "" {
if helpers.FilePathSeparator != cacheDir[len(cacheDir)-1:] {
cacheDir = cacheDir + helpers.FilePathSeparator
}
isDir, err := helpers.DirExists(cacheDir, hugofs.SourceFs)
utils.CheckErr(err)
if isDir == false {
mkdir(cacheDir)
}
viper.Set("CacheDir", cacheDir)
} else {
viper.Set("CacheDir", helpers.GetTempDir("hugo_cache", hugofs.SourceFs))
}
if verboseLog || logging || (viper.IsSet("LogFile") && viper.GetString("LogFile") != "") {
if viper.IsSet("LogFile") && viper.GetString("LogFile") != "" {
jww.SetLogFile(viper.GetString("LogFile"))
} else {
jww.UseTempLogFile("hugo")
}
} else {
jww.DiscardLogging()
}
if viper.GetBool("verbose") {
jww.SetStdoutThreshold(jww.LevelInfo)
}
if verboseLog {
jww.SetLogThreshold(jww.LevelInfo)
}
jww.INFO.Println("Using config file:", viper.ConfigFileUsed())
themeDir := helpers.GetThemeDir()
if themeDir != "" {
if _, err := os.Stat(themeDir); os.IsNotExist(err) {
return newSystemError("Unable to find theme Directory:", themeDir)
}
}
themeVersionMismatch, minVersion := isThemeVsHugoVersionMismatch()
if themeVersionMismatch {
jww.ERROR.Printf("Current theme does not support Hugo version %s. Minimum version required is %s\n",
helpers.HugoReleaseVersion(), minVersion)
}
return nil
}
func InitializeConfig() {
viper.SetConfigName(CfgFile)
viper.AddConfigPath(Source)
viper.ReadInConfig()
viper.SetDefault("ContentDir", "content")
viper.SetDefault("LayoutDir", "layouts")
viper.SetDefault("StaticDir", "static")
viper.SetDefault("PublishDir", "public")
viper.SetDefault("DefaultLayout", "post")
viper.SetDefault("BuildDrafts", false)
viper.SetDefault("UglyUrls", false)
viper.SetDefault("Verbose", false)
viper.SetDefault("CanonifyUrls", false)
viper.SetDefault("Indexes", map[string]string{"tag": "tags", "category": "categories"})
viper.SetDefault("Permalinks", make(hugolib.PermalinkOverrides, 0))
if hugoCmdV.PersistentFlags().Lookup("build-drafts").Changed {
viper.Set("BuildDrafts", Draft)
}
if hugoCmdV.PersistentFlags().Lookup("uglyurls").Changed {
viper.Set("UglyUrls", UglyUrls)
}
if hugoCmdV.PersistentFlags().Lookup("verbose").Changed {
viper.Set("Verbose", Verbose)
}
if hugoCmdV.PersistentFlags().Lookup("logfile").Changed {
viper.Set("LogFile", LogFile)
}
if BaseUrl != "" {
if !strings.HasSuffix(BaseUrl, "/") {
BaseUrl = BaseUrl + "/"
}
viper.Set("BaseUrl", BaseUrl)
}
if Destination != "" {
viper.Set("PublishDir", Destination)
}
if Source != "" {
viper.Set("WorkingDir", Source)
} else {
dir, _ := helpers.FindCWD()
viper.Set("WorkingDir", dir)
}
if VerboseLog || Logging || (viper.IsSet("LogFile") && viper.GetString("LogFile") != "") {
if viper.IsSet("LogFile") && viper.GetString("LogFile") != "" {
jww.SetLogFile(viper.GetString("LogFile"))
} else {
jww.UseTempLogFile("hugo")
}
} else {
jww.DiscardLogging()
}
if viper.GetBool("verbose") {
jww.SetStdoutThreshold(jww.LevelDebug)
}
if VerboseLog {
jww.SetLogThreshold(jww.LevelDebug)
}
jww.INFO.Println("Using config file:", viper.ConfigFileUsed())
}