Golang pflag.Bool函數代碼示例

func (cm *ConfigManager) parseFlags() {
	pflag.StringVarP(&cm.Flags.ConfigFile, "configfile", "c", DefaultConfigFile, "Path to config")
	pflag.StringVarP(&cm.Flags.DestHost, "dest-host", "d", "", "Destination syslog hostname or IP")
	pflag.IntVarP(&cm.Flags.DestPort, "dest-port", "p", 0, "Destination syslog port")
	if utils.CanDaemonize {
		pflag.BoolVarP(&cm.Flags.NoDaemonize, "no-detach", "D", false, "Don't daemonize and detach from the terminal")
	} else {
		cm.Flags.NoDaemonize = true
	}
	pflag.StringVarP(&cm.Flags.Facility, "facility", "f", "user", "Facility")
	pflag.StringVar(&cm.Flags.Hostname, "hostname", "", "Local hostname to send from")
	pflag.StringVar(&cm.Flags.PidFile, "pid-file", "", "Location of the PID file")
	// --parse-syslog
	pflag.StringVarP(&cm.Flags.Severity, "severity", "s", "notice", "Severity")
	// --strip-color
	pflag.BoolVar(&cm.Flags.UseTCP, "tcp", false, "Connect via TCP (no TLS)")
	pflag.BoolVar(&cm.Flags.UseTLS, "tls", false, "Connect via TCP with TLS")
	pflag.BoolVar(&cm.Flags.Poll, "poll", false, "Detect changes by polling instead of inotify")
	pflag.Var(&cm.Flags.RefreshInterval, "new-file-check-interval", "How often to check for new files")
	_ = pflag.Bool("no-eventmachine-tail", false, "No action, provided for backwards compatibility")
	_ = pflag.Bool("eventmachine-tail", false, "No action, provided for backwards compatibility")
	pflag.StringVar(&cm.Flags.DebugLogFile, "debug-log-cfg", "", "the debug log file")
	pflag.StringVar(&cm.Flags.LogLevels, "log", "<root>=INFO", "\"logging configuration <root>=INFO;first=TRACE\"")
	pflag.Parse()
	cm.FlagFiles = pflag.Args()
}

func Execute() {
	flag.Usage = printHelp

	doValidate := flag.Bool("validate", false, "Validates that the specified config file is valid.")
	doVersion := flag.Bool("version", false, "Prints the version information about the Frosty backup utility.")

	flag.Parse()

	switch {
	case *doValidate:
		validate(os.Args[1])
	case *doVersion:
		printVersion()
	default:
		backup(os.Args[1])
	}
}

func main() {
	flag.Usage = func() {
		fmt.Fprintf(os.Stderr, "usage: jp [file]\n")
		flag.PrintDefaults()
	}

	isTerminal := terminal.IsTerminal(int(os.Stdout.Fd()))

	compact := flag.Bool("compact", false, "compact format")
	colors := flag.Bool("color", isTerminal, "colored format")

	flag.Parse()
	args := flag.Args()
	if len(args) < 1 {
		flag.Usage()
		os.Exit(2)
	}

	format := "pretty"
	if *compact {
		format = "compact"
	}
	if *colors {
		format += "16"
	}

	var fd *os.File
	var e error
	if args[0] == "-" {
		fd = os.Stdin
	} else {
		fd, e = os.Open(args[0])
		if e != nil {
			fmt.Fprintln(os.Stderr, "Error:", e)
			os.Exit(1)
		}
	}

	e = jp.Expand(fd, os.Stdout, format)
	if e != nil {
		fmt.Fprintln(os.Stderr, "Error:", e)
		os.Exit(1)
	}
}

// Run parses the command line options in accordance with TODO(url) and runs the appropriate steps.
func (j *Job) Run() {
	var runMapper = flag.Bool("mapper", false, "Run the mapper")
	var runReducer = flag.Bool("reducer", false, "Run the mapper")
	var printSteps = flag.Bool("steps", false, "Print step descriptions")
	var stepNum = flag.Uint("step-num", 0, "Step number")

	flag.Parse()

	if *runMapper {
		j.Steps[*stepNum].runMapper()
	} else if *runReducer {
		err := j.Steps[*stepNum].runReducer()
		if err != nil && err != io.EOF {
			panic(err)
		}
	} else if *printSteps {
		j.printSteps()
	}
	return
}

	"log"
	"os"
	"os/exec"
	"path/filepath"
	"strings"
)

const APP_VERSION = "0.1"
const inputDelim = '\n'

var fileCount int = 0
var fileBytesRead int = 0
var fileBytesWritten int = 0

// The flag package provides a default help printer via -h switch
var versionFlag *bool = flag.Bool("v", false, "Print the version number.")

// Files
var FileSep = string(os.PathSeparator)
var LocalPkgs = []byte{'p', 'k', 'g', 's', '/'}

func main() {
	flag.Parse() // Scan the arguments list
	fmt.Fprintln(os.Stdout, LOGO)
	if *versionFlag {
		fmt.Println("Version:", APP_VERSION)
		return
	}
	cmd := flag.Arg(0)
	name := flag.Arg(1)
	switch cmd {

Written by Eric Lagergren
Inspired by David MacKenzie.`
	HELP = `Usage: tty [OPTION]...
Print the file name of the terminal connected to standard input.

  -s, --silent, --quiet   print nothing, only return an exit status
      --help     display this help and exit
      --version  output version information and exit

Report uname bugs to [email protected]
Go coreutils home page: <https://www.github.com/EricLagergren/go-coreutils/>`
)

var (
	version = flag.Bool("version", false, "print version")
	quiet1  = flag.BoolP("silent", "s", false, "no output")
	quiet2  = flag.Bool("quiet", false, "no output")
)

func main() {
	flag.Usage = func() {
		fmt.Fprintf(os.Stderr, "%s\n", HELP)
		return
	}
	flag.Parse()

	if *version {
		fmt.Printf("%s\n", VERSION)
		return
	}

	sparseNever
	sparseAuto
	sparseAlways
)

// backup enum
const (
	noBackups = iota
	simpleBackups
	numberedExistingBackups
	numberedBackups
)

var (
	archive           = flag.BoolP("archive", "a", false, "")
	attrOnly          = flag.Bool("attributes-only", false, "")
	backup            = flag.String("backup", "", "")
	backup2           = flag.Bool("b", false, "")
	copyContents      = flag.Bool("copy-contents", false, "")
	ndrpl             = flag.Bool("d", false, "")
	dereference       = flag.BoolP("dereference", "L", false, "")
	force             = flag.BoolP("force", "f", false, "")
	hopt              = flag.Bool("H", false, "")
	interactive       = flag.BoolP("interactive", "i", false, "")
	link              = flag.BoolP("link", "l", false, "")
	noClobber         = flag.BoolP("no-clobber", "n", false, "")
	noDereference     = flag.BoolP("no-dereference", "P", false, "")
	noPreserve        = flag.String("no-preserve", "", "")
	noTargetDir       = flag.BoolP("no-target-directory", "T", false, "")
	oneFS             = flag.BoolP("one-file-system", "x", false, "")
	parents           = flag.Bool("parents", false, "")

There is NO WARRANTY, to the extent permitted by law.

Written by Eric Lagergren`
)

var (
	dev = []byte("/dev/")
	bt  int32
)

var (
	all       = flag.BoolP("all", "a", false, "")
	boot      = flag.BoolP("boot", "b", false, "")
	dead      = flag.BoolP("dead", "d", false, "")
	heading   = flag.BoolP("heading", "H", false, "")
	ips       = flag.Bool("ips", false, "")
	login     = flag.BoolP("login", "l", false, "")
	cur       = flag.Bool("m", false, "")
	proc      = flag.BoolP("process", "p", false, "")
	count     = flag.BoolP("count", "q", false, "")
	rlvl      = flag.BoolP("runlevel", "r", false, "")
	short     = flag.BoolP("short", "s", false, "")
	clock     = flag.BoolP("time", "t", false, "")
	users     = flag.BoolP("users", "u", false, "")
	mesg      = flag.BoolP("mesg", "T", false, "")
	mesgTwo   = flag.BoolP("message", "w", false, "")
	mesgThree = flag.Bool("writable", false, "")
	doLookup  = flag.Bool("lookup", false, "")
	version   = flag.Bool("version", false, "")
)

	"github.com/mostafah/fsync"
	flag "github.com/ogier/pflag"
	"github.com/spf13/hugo/hugolib"
	"log"
	"net/http"
	"os"
	"path/filepath"
	"runtime/pprof"
	"sync"
	"time"
)

var (
	baseUrl     = flag.StringP("base-url", "b", "", "hostname (and path) to the root eg. http://spf13.com/")
	cfgfile     = flag.String("config", "", "config file (default is path/config.yaml|json|toml)")
	checkMode   = flag.Bool("check", false, "analyze content and provide feedback")
	draft       = flag.BoolP("build-drafts", "D", false, "include content marked as draft")
	help        = flag.BoolP("help", "h", false, "show this help")
	source      = flag.StringP("source", "s", "", "filesystem path to read files relative from")
	destination = flag.StringP("destination", "d", "", "filesystem path to write files to")
	verbose     = flag.BoolP("verbose", "v", false, "verbose output")
	version     = flag.Bool("version", false, "which version of hugo")
	cpuprofile  = flag.Int("profile", 0, "Number of times to create the site and profile it")
	watchMode   = flag.BoolP("watch", "w", false, "watch filesystem for changes and recreate as needed")
	server      = flag.BoolP("server", "S", false, "run a (very) simple web server")
	port        = flag.String("port", "1313", "port to run web server on, default :1313")
	uglyUrls    = flag.Bool("uglyurls", false, "use /filename.html instead of /filename/ ")
)

func usage() {
	PrintErr("usage: hugo [flags]", "")

Written by Eric Lagergren <[email protected]>
`
)

var (
	all        = flag.BoolP("show-all", "A", false, "")
	blank      = flag.BoolP("number-nonblank", "b", false, "")
	npEnds     = flag.BoolP("ends", "e", false, "")
	ends       = flag.BoolP("show-ends", "E", false, "")
	number     = flag.BoolP("number", "n", false, "")
	squeeze    = flag.BoolP("squeeze-blank", "s", false, "")
	npTabs     = flag.BoolP("tabs", "t", false, "")
	tabs       = flag.BoolP("show-tabs", "T", false, "")
	nonPrint   = flag.BoolP("non-printing", "v", false, "")
	unbuffered = flag.BoolP("unbuffered", "u", false, "")
	version    = flag.Bool("version", false, "")

	totalNewline    int64
	showNonPrinting bool

	fatal = log.New(os.Stderr, "", 0)
	// fatal = log.New(os.Stderr, "", log.Lshortfile)
)

const Caret = '^'

var (
	MDash    = []byte("M-")
	HorizTab = []byte("^I")
	Delete   = []byte("^?")

	log "maunium.net/go/maulogger"
	"maunium.net/go/mauth"
	"net/http"
	"os"
	"os/signal"
	"path/filepath"
	"strconv"
	"syscall"
)

const version = "2.1.0"

var debug = flag.BoolP("debug", "d", false, "Enable to print debug messages to stdout")
var confPath = flag.StringP("config", "c", "/etc/mis/config.json", "The path of the mauImageServer configuration file.")
var logPath = flag.StringP("logs", "l", "/var/log/mis", "The path of the mauImageServer configuration file.")
var disableSafeShutdown = flag.Bool("no-safe-shutdown", false, "Disable Interrupt/SIGTERM catching and handling.")

var config *data.Configuration
var database data.MISDatabase
var auth mauth.System

func main() {
	flag.Parse()

	if !*disableSafeShutdown {
		c := make(chan os.Signal, 1)
		signal.Notify(c, os.Interrupt, syscall.SIGTERM)
		go func() {
			<-c
			os.Stdout.Write([]byte("\n"))
			log.Infof("Shutting down mauImageServer...")

	"encoding/json"
	"fmt"
	log "github.com/alecthomas/log4go"
	"github.com/alecthomas/tuplespace"
	"github.com/alecthomas/tuplespace/client"
	"github.com/ogier/pflag"
	"os"
	"runtime"
	"time"
)

var (
	serverFlag  = pflag.String("server", "http://127.0.0.1:2619/tuplespace/", "tuplespace server address")
	timeoutFlag = pflag.Duration("timeout", time.Second*60, "tuplespace operation timeout")
	copiesFlag  = pflag.Int("copies", 1, "number of copies of the tuple to send")
	silentFlag  = pflag.Bool("silent", false, "don't display received tuples")
)

func fatalf(f string, args ...interface{}) {
	fmt.Fprintf(os.Stderr, "error: "+f+"\n", args...)
	os.Exit(1)
}

func parseTuple(arg string) (tuple tuplespace.Tuple) {
	err := json.Unmarshal([]byte(arg), &tuple)
	if err != nil {
		fatalf("invalid tuple (%s)", err.Error())
	}
	return
}

func main() {
	var err error

	log.Info(`Build 1.`)

	//============= Parse Command Line Flags ===================
	var UseStandaloneServer *bool = flag.Bool("server", false, `Launch as a standalone server.`)
	var IsDevEnv *bool = flag.Bool("dev", false, `Run in development mode.`)
	flag.Parse()
	//======================

	UserDataDir, err := malkovich.GetUserDataDirectory()
	log.Info(UserDataDir)

	var exeRoot string

	log.Info("start server...")

	UseSlackHook := false
	UseRequestLogger := true

	//log.SetLevel(log.PanicLevel)
	setupLogging(UseSlackHook)

	//=============  General Initialization ===================
	math_rand.Seed(time.Now().UTC().UnixNano())

	exeRoot, err = osext.ExecutableFolder()
	if err != nil {
		log.Fatalf("ERROR: %s", err.Error())
	} else {
		go log.Info("EXE Root: " + exeRoot)
	}

	UserDocRoot, err := malkovich.GetUserDocsDirectory()
	if err != nil {
		log.Fatalf("ERROR: User data directory not found. (%s)", err.Error())
		return
	}

	//=============  Router Initialization ===================
	router := mux.New()

	log.Infof("UserDocRoot = %s", UserDocRoot)

	commandsController := commands.New()
	commandsController.DocRoot = UserDocRoot
	router.POST("/api/v1/commands/pagefiles/:DocName/*filepath", commandsController.OpenFile)

	docServer := docs.New()
	docServer.DocRoot = UserDocRoot

	router.GET("/api/v1/frontpagedoc", docServer.GetFrontPageDocList)
	router.PUT("/api/v1/frontpagedoc/:name", docServer.CreateNewFrontPageDoc)
	router.GET("/api/v1/docs", docServer.GetDocList)
	router.GET("/api/v1/docs/:name/html", docServer.GetDocAsHtml)
	router.GET("/api/v1/docs/:name/md", docServer.GetDocAsMarkDown)
	router.PUT("/api/v1/docs/:name", docServer.UpdateDoc)
	router.DELETE("/api/v1/docs/:name", docServer.DeleteDoc)

	filesController := files.New()
	filesController.DirRoot = UserDocRoot
	FileRoutes := map[string]string{
		"ListFilesForDoc":  "/api/v1/files/list/:DocName",
		"UploadFile":       "/api/v1/files/uploadfile",
		"DeleteFile":       "/api/v1/files/delete/:DocName/*filepath",
		"ViewFile":         "/api/v1/files/view/:DocName/*filepath",
		"Command_OpenFile": "/api/v1/files/open/:DocName/*filepath",
		"Command_ShowFile": "/api/v1/files/show/:DocName/*filepath",
	}

	router.GET(FileRoutes["ListFilesForDoc"], filesController.ListForDoc)
	router.POST(FileRoutes["UploadFile"], filesController.UploadFile)
	router.DELETE(FileRoutes["DeleteFile"], filesController.DeleteFile)
	router.GET(FileRoutes["ViewFile"], filesController.ViewFile)
	router.POST(FileRoutes["Command_ShowFile"], filesController.ShowFile)

	//=== General file handling ===
	var wwwRoot string
	if *IsDevEnv {
		wwwRoot = exeRoot + path.Join("..", "Frontend", "public")
		wwwRoot = filepath.Clean(wwwRoot)
		// TODO:MED It would be good to check if the path exists here.
	} else {
		wwwRoot = path.Join(exeRoot, "www", "public")
		// TODO:MED It would be good to check if the path exists here.
	}
	wfs := webserver.New()
	wfs.DocRoot = wwwRoot
	router.NotFound = wfs.HandleNotFound

	chain := setupMiddleWareHandler(UseRequestLogger, router)

	if *UseStandaloneServer == true {
		runAsStandaloneServer(chain)
	} else {
		runServerWithGui(chain)
	}

}

var (
	config = replicator.Config{}

	metricFlags = metrics.RegisterMetricFlags(pflag.CommandLine)

	glogFlags struct {
		logToStderr     string
		alsoLogToStderr string
		verbosity       string
		vmodule         string
		logBacktraceAt  string
	}

	fleetDriver   = pflag.String("fleet-driver", "http", "The driver to use for connections to fleet. (http, etcd)")
	fleetEndpoint = pflag.String("fleet-peers", "unix:///var/run/fleet.sock", "List of peers for the fleet client (comma separated).")
	dryRun        = pflag.Bool("dry-run", true, "Do not write to fleet.")
)

func init() {
	pflag.DurationVar(&config.TickerTime, "ticker-time", 60*time.Second, "Ticker time.")
	pflag.DurationVar(&config.DeleteTime, "delete-time", 60*time.Minute, "Time before deleting undesired units.")
	pflag.DurationVar(&config.UpdateCooldownTime, "update-cooldown-time", 15*time.Minute, "Time between updates of changed units.")

	pflag.StringVar(&config.MachineTag, "machine-tag", "", "The machine-tag to filter for.")
	pflag.StringVar(&config.UnitTemplate, "unit-template", "", "The template to render for new units. Prefix with @ to load from a file.")
	pflag.StringVar(&config.UnitPrefix, "unit-prefix", "", "The prefix for the units to identify.")

	pflag.StringVar(&glogFlags.logToStderr, "logtostderr", "true", "log to standard error instead of files")
	pflag.StringVar(&glogFlags.alsoLogToStderr, "alsologtostderr", "false", "log to standard error as well as files")
	pflag.StringVarP(&glogFlags.verbosity, "verbose", "v", "1", "log level for V logs")
	pflag.StringVar(&glogFlags.vmodule, "vmodule", "", "comma-separated list of pattern=N settings for file-filtered logging")

	Left  *ListData
	Right *ListData
}

var (
	drawChan            chan bool
	newContainerChan    chan goDocker.Container
	removeContainerChan chan string
	doneChan            chan bool
	uiEventChan         chan view.UIEvent
	drawStatsChan       chan docklistener.StatsMsg
)

var logFileFlag = flag.String("log-file", "", "Path to log file")
var dockerEndpoint = flag.String("docker-endpoint", "", "Docker connection endpoint")
var helpFlag = flag.Bool("help", false, "help")
var versionFlag = flag.Bool("version", false, "print version")

func init() {
	flag.Usage = func() {
		fmt.Fprintf(os.Stderr, "Usage: dockdash [options]\n\n")
		flag.PrintDefaults()
	}

	flag.Parse()

	if *helpFlag {
		flag.Usage()
		os.Exit(1)
	}
	if *versionFlag {