func init() {
	jww.SetLogThreshold(jww.LevelTrace)
	jww.SetStdoutThreshold(jww.LevelInfo)

	log.Println("initing config ...")

	viper.SetConfigName("zookeeper-helper")
	viper.AddConfigPath("./")
	viper.AddConfigPath("$HOME/.omega/")
	viper.AddConfigPath("/etc/omega/")
	viper.SetConfigType("yaml")

	if err := viper.ReadInConfig(); err != nil {
		log.Panicln("can't read config file:", err)
	}

	initDefault()

	if err := viper.Unmarshal(&pairs); err != nil {
		log.Panicln("can't covert to config pairs: ", err)
	}

	if !pairs.Debugging {
		jww.SetLogThreshold(jww.LevelError)
		jww.SetStdoutThreshold(jww.LevelError)
	}

	log.Printf("initialized config pairs: %+v\n", pairs)
}

func (c *Config) SetLogFile(s string) {
	if c.verbose {
		jww.SetLogThreshold(jww.LevelDebug)
		jww.SetStdoutThreshold(jww.LevelInfo)
	} else {
		jww.SetLogThreshold(jww.LevelWarn)
		jww.SetStdoutThreshold(jww.LevelError)
	}
	jww.SetLogFile(s)
}

func TestCheckExcuse(t *testing.T) {
	if testing.Verbose() {
		log.SetLogThreshold(log.LevelInfo)
		log.SetStdoutThreshold(log.LevelInfo)
	}

	createEmptyGitRepo(t)

	runCheckP(t, "foobar", true, "foo,5")
	// Increase on "barfoo" prefix is okay
	runCheckP(t, "barfoo", true, "foo,6")

	t.Logf("Running check command p: %s w: %t i: %s", "foobar", false, "foo,6")

	errCode := Check("foobar", 0, false, "csv", false, strings.NewReader("foo,6"))

	if errCode != 50 {
		t.Fatalf("Check command passed unexpectedly!")
	}

	writeExcuse(t, "foobar", "foo", "PROD's down right now, I'll clean foo up later")

	runCheckP(t, "foobar", true, "foo,6")

	t.Logf("Running check command p: %s w: %t i: %s", "barfoo", false, "foo,7")

	errCode = Check("barfoo", 0, false, "csv", false, strings.NewReader("foo,7"))

	if errCode != 50 {
		t.Fatalf("Check command passed unexpectedly!")
	}
}

func TestCheckWithCheckstyleInput(t *testing.T) {
	if testing.Verbose() {
		log.SetLogThreshold(log.LevelInfo)
		log.SetStdoutThreshold(log.LevelInfo)
	}

	if checkStyleFileErr != nil {
		t.Fatalf("Failure opening test data", checkStyleFileErr)
	}

	createEmptyGitRepo(t)

	t.Logf("Running check command p: %s w: %t i: %s", "jshint", true, checkStyleFile)

	errCode := Check("jshint", 0, true, "checkstyle", false, checkStyleFile)

	if errCode != 0 {
		t.Fatalf("Check command failed! Error code: %d", errCode)
	}

	t.Logf("Running check command p: %s w: %t i: %s", "jshint", false, "errors,951")

	errCode = Check("jshint", 0, false, "csv", false, strings.NewReader("errors,951"))

	if errCode != 50 {
		t.Fatalf("Check command passed unexpectedly!")
	}
}

func TestDump(t *testing.T) {
	if testing.Verbose() {
		log.SetLogThreshold(log.LevelInfo)
		log.SetStdoutThreshold(log.LevelInfo)
	}

	repo := createEmptyGitRepo(t)

	runCheckP(t, "foo", true, "foo,5")
	runCommand(t, repo, exec.Command("git", "add", createFile(t, repo, "bar.txt").Name()))
	runCommand(t, repo, exec.Command("git", "commit", "-m", "Third Commit"))
	runCheckP(t, "foo", true, "foo,4")

	dump := bufio.NewScanner(bytes.NewReader(runDump(t, "foo").Bytes()))

	dump.Scan()

	checkString(t, "foo,4,4", dump.Text())

	dump.Scan()

	checkString(t, "foo,5,5", dump.Text())

	if len(runDump(t, "bar").Bytes()) > 0 {
		t.Fatalf("Should be no data under prefix bar")
	}
}

func TestZeroMissing(t *testing.T) {
	if testing.Verbose() {
		log.SetLogThreshold(log.LevelInfo)
		log.SetStdoutThreshold(log.LevelInfo)
	}

	createEmptyGitRepo(t)

	runCheck(t, true, "foo,5")

	t.Logf("Running check command w: %t i: %s", false, "")

	errCode := Check("", 0, true, "csv", false, strings.NewReader(""))

	if errCode != 50 {
		t.Fatalf("Check command passed unexpectedly!")
	}

	t.Logf("Running check command zero on missing w: %t i: %s", false, "")

	errCode = Check("", 0, true, "csv", false, strings.NewReader(""))

	if errCode != 0 {
		t.Fatalf("Check command failed unexpectedly!")
	}
}

func TestCheckSlackPercent(t *testing.T) {
	if testing.Verbose() {
		log.SetLogThreshold(log.LevelInfo)
		log.SetStdoutThreshold(log.LevelInfo)
	}

	createEmptyGitRepo(t)

	slack := 20.0
	usePercents := true

	runCheckPS(t, "pageweight", slack, usePercents, true, "gzippedjs,100")
	runCheckPS(t, "pageweight", slack, usePercents, false, "gzippedjs,101")

	t.Logf("Running check command p: %s w: %t i: %s", "pageweight", false, "gzippedjs,120")

	errCode := Check("pageweight", slack, usePercents, false, "csv", false, strings.NewReader("gzippedjs,120"))

	if errCode != 0 {
		t.Fatalf("Check command failed unexpectedly!")
	}

	t.Logf("Running check command p: %s w: %t i: %s", "pageweight", false, "gzippedjs,121")

	errCode = Check("pageweight", slack, usePercents, false, "csv", false, strings.NewReader("gzippedjs,121"))

	if errCode != 50 {
		t.Fatalf("Check command passed unexpectedly!")
	}
}

// InitializeConfig reads in config file and ENV variables if set.
func InitializeConfig(subCmdVs ...*cobra.Command) error {
	viper.SetConfigType("json")
	viper.SetConfigName("grasshopper") // name of config file (without extension)
	//	viper.AddConfigPath("/etc/grasshopper.d/")  // path to look for the config file
	//	viper.AddConfigPath("$HOME/.grasshopper.d") // call multiple times to add many search paths
	viper.AddConfigPath(".") // optionally look for config in the working directory

	// read config from storage
	err := viper.ReadInConfig()
	if err != nil {
		jww.WARN.Printf("Unable to read Config file. %#v I will fall back to my defaults...", err)
		err = nil // we just skip this error
	}

	// set some sane defaults
	viper.SetDefault("Verbose", false)
	viper.SetDefault("Quiet", false)
	viper.SetDefault("Log", true)
	viper.SetDefault("Experimental", true)

	if grasshopperCmdV.PersistentFlags().Lookup("verbose").Changed {
		viper.Set("Verbose", Verbose)
	}

	if viper.GetBool("verbose") {
		jww.SetStdoutThreshold(jww.LevelTrace)
		jww.SetLogThreshold(jww.LevelTrace)
	}

	return err
}

func init() {
	GrasshopperCmd.PersistentFlags().BoolVarP(&Verbose, "verbose", "v", false, "verbose output")
	GrasshopperCmd.PersistentFlags().BoolVarP(&Quiet, "quiet", "q", false, "quiet output")
	GrasshopperCmd.PersistentFlags().BoolVarP(&Log, "log", "l", true, "write logging output to file")
	GrasshopperCmd.PersistentFlags().BoolVarP(&Experimental, "experimental", "x", true, "write experimental output to stdout")

	grasshopperCmdV = GrasshopperCmd

	viper.BindPFlag("verbose", GrasshopperCmd.PersistentFlags().Lookup("verbose"))
	viper.BindPFlag("quiet", GrasshopperCmd.PersistentFlags().Lookup("quiet"))
	viper.BindPFlag("log", GrasshopperCmd.PersistentFlags().Lookup("log"))
	viper.BindPFlag("experimental", GrasshopperCmd.PersistentFlags().Lookup("experimental"))

	if Log {
		jww.SetLogFile("grasshopper.log")
	}

	if Quiet {
		jww.SetStdoutThreshold(jww.LevelWarn)
	}

	if Verbose {
		jww.SetLogThreshold(jww.LevelTrace)
		jww.SetStdoutThreshold(jww.LevelTrace)
	}

}

// initialize logging...
func initLogging(configuration *Configuration) {

	log.SetLogFile(configuration.LogFile)

	threshold := configuration.LogThreshold
	if threshold == "TRACE" {
		log.SetLogThreshold(log.LevelTrace)
		log.SetStdoutThreshold(log.LevelTrace)
	} else if threshold == "DEBUG" {
		log.SetLogThreshold(log.LevelDebug)
		log.SetStdoutThreshold(log.LevelDebug)
	} else if threshold == "INFO" {
		log.SetLogThreshold(log.LevelInfo)
		log.SetStdoutThreshold(log.LevelInfo)
	} else if threshold == "WARN" {
		log.SetLogThreshold(log.LevelWarn)
		log.SetStdoutThreshold(log.LevelWarn)
	} else if threshold == "ERROR" {
		log.SetLogThreshold(log.LevelError)
		log.SetStdoutThreshold(log.LevelError)
	} else if threshold == "CRITICAL" {
		log.SetLogThreshold(log.LevelCritical)
		log.SetStdoutThreshold(log.LevelCritical)
	} else if threshold == "FATAL" {
		log.SetLogThreshold(log.LevelFatal)
		log.SetStdoutThreshold(log.LevelFatal)
	}
}

//FetchFunction is the function that downloads all Nulecule container images
func FetchFunction(cmd *cobra.Command, args []string) {
	if Verbose {
		jww.SetLogThreshold(jww.LevelTrace)
		jww.SetStdoutThreshold(jww.LevelInfo)
	}

	if len(args) < 1 {
		cmd.Usage()
		jww.FATAL.Println("URL to be fetched is missing")
	}

	jww.INFO.Printf("fetching: %q", strings.Join(args, " "))
}

func printIndexList(cmd *cobra.Command, args []string) {
	InitializeConfig()

	if Verbose {
		jww.SetLogThreshold(jww.LevelTrace)
		jww.SetStdoutThreshold(jww.LevelInfo)
	}

	nuleculeLibraryIndexZip, err := getNuleculeLibraryIndexfromGithubAsZIP()
	if err != nil {
		jww.FATAL.Println(err)
		return
	}

	w := new(tabwriter.Writer)
	w.Init(os.Stdout, 26, 8, 2, '\t', 0)

	fmt.Fprintln(w, "This is the Nulecule Library Index")
	fmt.Fprintln(w, "Application Name\tAppID\tVersion")

	// Iterate through the files in the archive
	for _, item := range nuleculeLibraryIndexZip.File {
		if item.FileInfo().IsDir() {
			continue
		}

		// if the file is a Nulecule, getit!
		if item.FileInfo().Name() == "Nulecule" {
			jww.DEBUG.Printf("Found a Nulecule, size of it's description is %d\n", item.FileInfo().Size())

			rc, err := item.Open()
			if err != nil {
				jww.FATAL.Println(err)
				return
			}
			defer rc.Close()

			// get the Nulecules content
			nuci, parseError := nulecule.Parse(rc)

			if parseError != nil {
				jww.INFO.Println(parseError, " This may be due to unsupported (by Grasshopper) artifact inheritance.")
				continue
			}

			fmt.Fprintf(w, "%s\t%s\t%s\n", nuci.Metadata.Name, nuci.AppID, nuci.Metadata.AppVersion)
		}

		w.Flush()
	}
}

// InitializeConfig initializes a config file with sensible default configuration flags.
func InitializeConfig() {
	if Quiet {
		jww.SetStdoutThreshold(jww.LevelWarn)
	}

	viper.SetConfigName("grasshopper")          // name of config file (without extension)
	viper.AddConfigPath("/etc/grasshopper.d/")  // path to look for the config file
	viper.AddConfigPath("$HOME/.grasshopper.d") // call multiple times to add many search paths
	viper.AddConfigPath(".")                    // optionally look for config in the working directory

	// read config from storage
	err := viper.ReadInConfig() // FIXME
	if err != nil {
		jww.WARN.Println("Unable to locate Config file. I will fall back to my defaults...")
	}

	// default settings
	viper.SetDefault("Verbose", false)
	viper.SetDefault("Quiet", false)
	viper.SetDefault("DryRun", false)
	viper.SetDefault("DoLog", true)
	viper.SetDefault("Experimental", true)

	// bind config to command flags
	if grasshopperCmdV.PersistentFlags().Lookup("verbose").Changed {
		viper.Set("Verbose", Verbose)
	}
	if grasshopperCmdV.PersistentFlags().Lookup("quiet").Changed {
		viper.Set("Quiet", Quiet)
	}
	if grasshopperCmdV.PersistentFlags().Lookup("log").Changed {
		viper.Set("DoLog", DoLog)
	}
	if grasshopperCmdV.PersistentFlags().Lookup("experimental").Changed {
		viper.Set("Experimental", Experimental)
	}

	if DoLog {
		jww.SetLogFile("grasshopper.log")
	}

	if Verbose {
		jww.SetLogThreshold(jww.LevelTrace)
		jww.SetStdoutThreshold(jww.LevelTrace)
	}
}

//Execute adds all child commands to the root command GrasshopperCmd and sets flags appropriately.
func Execute() {
	if Verbose {
		jww.SetLogThreshold(jww.LevelTrace)
		jww.SetStdoutThreshold(jww.LevelInfo)
	}

	if DoLog {
		jww.SetLogFile("grasshopper.log")
	}

	jww.DEBUG.Println("Gentlemen, start your engines!!")
	GrasshopperCmd.SuggestionsMinimumDistance = 1

	//add child commands to the root command.
	GrasshopperCmd.AddCommand(versionCmd)

	// FIXME unsupported bashAutogenerateCmd
	// GrasshopperCmd.AddCommand(bashAutogenerateCmd)

	GrasshopperCmd.AddCommand(IndexCmd)

	GrasshopperCmd.AddCommand(FetchCmd)
	GrasshopperCmd.AddCommand(InstallCmd)
	GrasshopperCmd.AddCommand(RunCmd)
	GrasshopperCmd.AddCommand(StopCmd)
	GrasshopperCmd.AddCommand(UninstallCmd)
	GrasshopperCmd.AddCommand(CleanCmd)

	/* FIxME this is nice, but we need a better one!
	manHeader := &cobra.GenManHeader{
		Title:   "grasshopper",
		Section: "1",
	}
	out := new(bytes.Buffer)
	GrasshopperCmd.GenMan(manHeader, out)
	fmt.Println(out.String())
	*/

	if err := GrasshopperCmd.Execute(); err != nil {
		// the err is already logged by Cobra
		os.Exit(-1)
	}

}

func TestCheckExcuse(t *testing.T) {
	if testing.Verbose() {
		log.SetLogThreshold(log.LevelInfo)
		log.SetStdoutThreshold(log.LevelInfo)
	}

	repo := createEmptyGitRepo(t)

	runCheckP(t, "foobar", true, "foo,5")
	// Increase on "barfoo" prefix is okay
	runCheckP(t, "barfoo", true, "foo,6")

	t.Logf("Running check command p: %s w: %t i: %s", "foobar", false, "foo,6")

	errCode := Check("foobar", 0, false, false, "csv", false, strings.NewReader("foo,6"))

	if errCode != 50 {
		t.Fatalf("Check command passed unexpectedly!")
	}

	writeExcuse(t, "foobar", "foo", "PROD's down right now, I'll clean foo up later")

	runCheckP(t, "foobar", true, "foo,6")

	t.Logf("Running check command p: %s w: %t i: %s", "barfoo", false, "foo,7")

	errCode = Check("barfoo", 0, false, false, "csv", false, strings.NewReader("foo,7"))

	if errCode != 50 {
		t.Fatalf("Check command passed unexpectedly!")
	}

	runCommand(t, repo, exec.Command("git", "add", createFile(t, repo, "test2.txt").Name()))
	runCommand(t, repo, exec.Command("git", "commit", "-m", "Third Commit"))

	runCheckP(t, "foobar", true, "foo,6")

	runCommand(t, repo, exec.Command("git", "add", createFile(t, repo, "test3.txt").Name()))
	runCommand(t, repo, exec.Command("git", "commit", "-m", "Fourth Commit"))

	runCheckP(t, "foobar", true, "foo,6")
}

func TestCheckPrefix(t *testing.T) {
	if testing.Verbose() {
		log.SetLogThreshold(log.LevelInfo)
		log.SetStdoutThreshold(log.LevelInfo)
	}

	createEmptyGitRepo(t)

	runCheckP(t, "foobar", true, "foo,5")
	// Running a check against a different prefix should still work
	runCheckP(t, "barfoo", true, "foo,6")

	t.Logf("Running check command p: %s w: %t i: %s", "foobar", false, "foo,6")

	errCode := Check("foobar", 0, false, "csv", false, strings.NewReader("foo,6"))

	if errCode != 50 {
		t.Fatalf("Check command passed unexpectedly!")
	}
}

//.........这里部分代码省略.........
	viper.SetDefault("ArchetypeDir", "archetypes")
	viper.SetDefault("PublishDir", "public")
	viper.SetDefault("DefaultLayout", "post")
	viper.SetDefault("BuildDrafts", false)
	viper.SetDefault("BuildFuture", 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))
	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", new(helpers.Blackfriday))

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

//.........这里部分代码省略.........
		viper.AddConfigPath(".")
	} else {
		viper.AddConfigPath(Source)
	}
	err := viper.ReadInConfig()
	if err != nil {
		jww.ERROR.Println("Unable to locate Config file.")
	}
	LoadDefaultSettings()

	if hugoCMSCmdV.PersistentFlags().Lookup("disableRSS").Changed {
		viper.Set("DisableRSS", DisableRSS)
	}

	if hugoCMSCmdV.PersistentFlags().Lookup("disableSitemap").Changed {
		viper.Set("DisableSitemap", DisableSitemap)
	}

	if hugoCMSCmdV.PersistentFlags().Lookup("verbose").Changed {
		viper.Set("Verbose", Verbose)
	}

	if hugoCMSCmdV.PersistentFlags().Lookup("pluralizeListTitles").Changed {
		viper.Set("PluralizeListTitles", PluralizeListTitles)
	}

	if hugoCMSCmdV.PersistentFlags().Lookup("preserveTaxonomyNames").Changed {
		viper.Set("PreserveTaxonomyNames", PreserveTaxonomyNames)
	}

	if hugoCMSCmdV.PersistentFlags().Lookup("editor").Changed {
		viper.Set("NewContentEditor", Editor)
	}

	if hugoCMSCmdV.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 hugoCMSCmdV.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)
	}

}

func main() {
	flgVerbose := flag.Bool("verbose", false, "Output additional debugging information to both STDOUT and the log file")
	flgPortNum := flag.Int("port", 8777, "The port to run the HTTP server on.") // 8777 = "WM"
	flgConfigPath := flag.String("conf", "weathermoss-conf.json", "Path to the config JSON file")
	flgVersion := flag.Bool("version", false, "Show version information and quit.")
	flag.Parse()

	if *flgVersion {
		fmt.Println("Weathermoss version", version)
		os.Exit(0)
	}

	// Note at this point only WARN or above is actually logged to file, and ERROR or above to console.
	jww.SetLogFile("weathermoss.log")

	// Set extra logging if the command line flag was set
	if *flgVerbose {
		jww.SetLogThreshold(jww.LevelDebug)
		jww.SetStdoutThreshold(jww.LevelInfo)
		jww.INFO.Println("Verbose debug level set.")
	} else {
		// Set custom default logging verbosity.
		jww.SetLogThreshold(jww.LevelWarn)
		jww.SetStdoutThreshold(jww.LevelError)
	}

	// Read config file
	appconf, err := getConfigFromFile(*flgConfigPath)
	if err != nil {
		jww.FATAL.Println("Configuration Error:", err)
		os.Exit(1)
	}

	// Set up something to handle ctrl-c/kill cleanup!
	c := make(chan os.Signal, 1)
	signal.Notify(c, os.Interrupt)
	signal.Notify(c, syscall.SIGTERM)
	go func() {
		<-c
		fmt.Println("")
		// TODO: Graceful cleanup http's listenAndServe runner?
		// TODO: Any other cleanup needed?
		fmt.Println("Cleaned up and shut down.")
		os.Exit(0)
	}()

	jww.DEBUG.Println(fmt.Sprintf("Connecting to db: %s:%[email protected](%s:%s)/%s?parseTime=true", appconf.DB.Username, appconf.DB.Password, appconf.DB.Host, appconf.DB.Port, appconf.DB.Database))
	db, err := sql.Open("mysql", fmt.Sprintf("%s:%[email protected](%s:%s)/%s?parseTime=true", appconf.DB.Username, appconf.DB.Password, appconf.DB.Host, appconf.DB.Port, appconf.DB.Database))
	if err != nil {
		jww.FATAL.Println("Failed to open database. Error was:", err)
		os.Exit(1)
	}

	if err := db.Ping(); err != nil {
		jww.FATAL.Println("Failed to open database. Error was:", err)
		os.Exit(1)
	}

	// Somewhat arbitrary. TODO: Tune as necessary.
	db.SetMaxIdleConns(500)
	db.SetMaxOpenConns(1000)

	// Set up the HTTP router, followed by all the routes
	router := bone.New()

	// Redirect static resources, and then handle the static resources (/gui/) routes with the static asset file
	router.Handle("/", http.HandlerFunc(func(response http.ResponseWriter, request *http.Request) {
		http.Redirect(response, request, "gui/", 302)
	}))
	router.Get("/gui/", http.StripPrefix("/gui/", http.FileServer(&assetfs.AssetFS{Asset: Asset, AssetDir: AssetDir, Prefix: ""})))

	router.GetFunc("/api", func(w http.ResponseWriter, r *http.Request) {
		w.Write([]byte("Welcome to Weathermoss"))
	})

	// Define the API (JSON) routes
	api := api.NewApiHandlers(db)
	router.GetFunc("/api/current", api.Current)
	router.GetFunc("/api/ws", api.WsCombinedHandler)
	router.GetFunc("/api/ws/10min", api.WsTenMinuteHandler)
	router.GetFunc("/api/ws/15sec", api.WsFifteenSecHandler)

	// Start the HTTP server
	fmt.Println("Starting API server on port", *flgPortNum, ". Press Ctrl-C to quit.")
	http.ListenAndServe(fmt.Sprintf(":%d", *flgPortNum), router)
}

func main() {
	var write bool
	var verbose bool
	var prefix string
	var slack int
	var inputType string

	var versionCmd = &cobra.Command{
		Use:   "version",
		Short: "Print the version number",
		Long:  `All software has versions.`,
		Run: func(cmd *cobra.Command, args []string) {
			fmt.Printf("git-ratchet version: %s\n", GitTag)
		},
	}

	var checkCmd = &cobra.Command{
		Use:   "check",
		Short: "Checks the values passed in against the most recent stored values.",
		Long: `Checks the values passed in against the most recent stored values. 
The most recent stored values are found by walking up the commit graph and looking at the git-notes stored.`,
		Run: func(cmd *cobra.Command, args []string) {
			if verbose {
				log.SetLogThreshold(log.LevelInfo)
				log.SetStdoutThreshold(log.LevelInfo)
			}

			err := ratchet.Check(prefix, slack, write, inputType, os.Stdin)
			if err != 0 {
				os.Exit(err)
			}
		},
	}

	checkCmd.Flags().BoolVarP(&write, "write", "w", false, "write values if no increase is detected. only use on your CI server.")
	checkCmd.Flags().IntVarP(&slack, "slack", "s", 0, "slack value, increase within the range of the slack is acceptable.")
	checkCmd.Flags().StringVarP(&inputType, "inputType", "i", "csv", "input type. csv and checkstyle available.")

	var measure string
	var excuse string

	var excuseCmd = &cobra.Command{
		Use:   "excuse",
		Short: "Write an excuse for a measurement increase.",
		Long:  `Write an excuse for a measurement increase. This will allow the check command to pass.`,
		Run: func(cmd *cobra.Command, args []string) {
			if verbose {
				log.SetLogThreshold(log.LevelInfo)
				log.SetStdoutThreshold(log.LevelInfo)
			}

			os.Exit(ratchet.Excuse(prefix, measure, excuse))
		},
	}

	excuseCmd.Flags().StringVarP(&measure, "name", "n", "", "names of the measures to excuse, comma separated list.")
	excuseCmd.Flags().StringVarP(&excuse, "excuse", "e", "", "excuse for the measure rising.")

	var dumpCmd = &cobra.Command{
		Use:   "dump",
		Short: "Dump a CSV file containing the measurement data over time.",
		Long:  `Dump a CSV file containing the measurement data over time.`,
		Run: func(cmd *cobra.Command, args []string) {
			if verbose {
				log.SetLogThreshold(log.LevelInfo)
				log.SetStdoutThreshold(log.LevelInfo)
			}

			err := ratchet.Dump(prefix, os.Stdout)

			if err != 0 {
				os.Exit(err)
			}
		},
	}

	var rootCmd = &cobra.Command{Use: "git-ratchet"}
	rootCmd.AddCommand(checkCmd, excuseCmd, dumpCmd, versionCmd)
	rootCmd.PersistentFlags().BoolVarP(&verbose, "verbose", "v", false, "increase logging verbosity.")
	rootCmd.PersistentFlags().StringVarP(&prefix, "prefix", "p", "master", "prefix the ratchet notes. useful for storing multiple sets of values in the same repo.")

	rootCmd.Execute()
}