func (r Registry) Main(ctx *Context, args []string) { opts := optparse.Parser("Usage: bolt <command-1> <command-2> ... [options]\n", "bolt 0.1") opts.String([]string{"--boltfile"}, "", "use the Boltfile at the given path", "PATH") opts.String([]string{"--gen"}, "", "save the generated executable at the given path", "PATH") opts.Bool([]string{"--recompile"}, false, "recompile the generated executable instead of using cached builds") noConsoleLog := opts.BoolConfig("no-console-log", false, "disable logging to the console [false]") completions := append(ctx.completions, r.Keys()...) opts.Completer = optparse.ListCompleter(completions...) opts.Parse(args) if len(args) == 1 { listing := r.Listing() fmt.Print(listing) runtime.Exit(0) } if !*noConsoleLog { log.AddConsoleLogger() } buf := &bytes.Buffer{} yaml.NormaliseID(buf, args[1]) cmd := buf.String() if task, ok := r[cmd]; ok { task.Func.Call([]reflect.Value{reflect.ValueOf(ctx)}) } else { fmt.Printf("Task not found:\n\n\t%s\n\n", args[1]) runtime.Exit(1) } }
func main() { opts := optparse.Parser( "Usage: matchdb <config.yaml> [options]\n", "matchdb 0.0.1") host := opts.StringConfig("host", "", "the host to bind matchdb to") port := opts.IntConfig("port", 8090, "the port to bind matchdb to [8090]") allocLimit := opts.IntConfig("alloc-limit", 5000000, "maximum allocation limit in kilobytes [5000000]") hashKey := opts.StringConfig("hash-key", "", "16-byte hash key encoded as a 32-byte hex string") awsAccessKey := opts.StringConfig("aws-access-key", "", "the AWS Access Key for DynamoDB") awsSecretKey := opts.StringConfig("aws-secret-key", "", "the AWS Secret Key for DynamoDB") awsRegion := opts.StringConfig("aws-region", "us-east-1", "the AWS Region for DynamoDB [us-east-1]") masterTable := opts.StringConfig("master-table", "", "the DynamoDB table for the master lock") masterTimeout := opts.IntConfig("master-timeout", 6000, "timeout in milliseconds for the master lock [6000]") os.Args[0] = "matchdb" runtime.DefaultOpts("matchdb", opts, os.Args) initHashKey(*hashKey) master := NewMaster("", *awsAccessKey, *awsSecretKey, *awsRegion, *masterTable, time.Duration(*masterTimeout)*time.Millisecond) db := &DB{} db.Run(*host, *port, master, int64(*allocLimit)) }
func main() { opts := optparse.Parser("Usage: genapi [options]", "0.1") root := opts.String( []string{"-r", "--root"}, "../src/espra", "path to the root package directory for the app", "PATH") ignoreList := opts.String( []string{"-i", "--ignore"}, "api.go html.go", "space-separated list of files/subdirectories to ignore", "LIST") digestFile := opts.String( []string{"-d", "--digest"}, "../etc/app/version.digest", "path to write the digest of the API version", "PATH") os.Args[0] = "genapi" opts.Parse(os.Args) log.AddConsoleLogger() ignore := strings.Split(*ignoreList, " ") for i, path := range ignore { ignore[i] = filepath.Join(*root, path) } pkgpath := strings.Split(*root, "/") pkgname := pkgpath[len(pkgpath)-1] if err := parseDirectory(pkgname, pkgname, *root, ignore); err != nil { runtime.StandardError(err) } for _, method := range methods { log.Info("%#v", method) } log.Wait() _ = *digestFile }
func main() { // Define the options for the command line and config file options parser. opts := optparse.Parser( "Usage: matchweb <config.yaml> [options]\n", "matchweb 0.0.1") host := opts.StringConfig("host", "", "the host to bind the matchweb to") port := opts.IntConfig("port", 9040, "the port to bind the matchweb to [9040]") redirectURL := opts.StringConfig("redirect-url", "", "the URL that the HTTP Redirector redirects to") redirectorHost := opts.StringConfig("redirector-host", "", "the host to bind the HTTP Redirector to") redirectorPort := opts.IntConfig("redirector-port", 9080, "the port to bind the HTTP Redirector to [9080]") hstsMaxAge := opts.IntConfig("hsts-max-age", 31536000, "max-age value of HSTS in number of seconds [0 (disabled)]") clusterID := opts.StringConfig("cluster-id", "", "the cluster id to use when responding to ping requests") matchdbServer := opts.StringConfig("matchdb-server", "", "the address for a single-node MatchDB server setup") hashKey := opts.StringConfig("hash-key", "", "16-byte hash key encoded as a 32-byte hex string") awsAccessKey := opts.StringConfig("aws-access-key", "", "the AWS Access Key for DynamoDB") awsSecretKey := opts.StringConfig("aws-secret-key", "", "the AWS Secret Key for DynamoDB") awsRegion := opts.StringConfig("aws-region", "us-east-1", "the AWS Region for DynamoDB [us-east-1]") masterTable := opts.StringConfig("master-table", "", "the DynamoDB table for the master lock") masterTimeout := opts.IntConfig("master-timeout", 6000, "timeout in milliseconds for the master lock [6000]") routingTimeout := opts.IntConfig("routing-timeout", 3000, "timeout in milliseconds for routing entries [3000]") publishKey := opts.StringConfig("publish-key", "", "the shared secret for publishing new items") publishClusterID := opts.IntConfig("publish-cluster-id", 0, "the cluster id to use when acknowledging publish requests") upstreamHost := opts.StringConfig("upstream-host", "localhost", "the upstream host to connect to [localhost]") upstreamPort := opts.IntConfig("upstream-port", 8080, "the upstream port to connect to [8080]") upstreamTLS := opts.BoolConfig("upstream-tls", false, "use TLS when connecting to upstream [false]") websocketOrigin := opts.StringConfig("websocket-origin", "", "limit websocket calls to the given origin if specified") maintenanceMode := opts.BoolConfig("maintenance", false, "start up in maintenance mode [false]") // Setup the console log filter. log.ConsoleFilters[logPrefix] = func(items []interface{}) (bool, []interface{}) { return true, items[2 : len(items)-2] } // Parse the command line options. os.Args[0] = "matchweb" runtime.DefaultOpts("matchweb", opts, os.Args) // Initialise the TLS config. tlsconf.Init() // Initialise ping/pong variables. setupPong("matchweb", *clusterID) // Initialise the key for hashing slots. initHashKey(*hashKey) // Ensure required config values. if *publishKey == "" { runtime.Error("The publish-key cannot be empty") } server := &LiveServer{ httpClient: &http.Client{Transport: &http.Transport{TLSClientConfig: tlsconf.Config}}, publishKey: []byte(*publishKey), publishKeyLength: len(*publishKey), websocketOrigin: *websocketOrigin, } setUpstreamInfo(server, *upstreamHost, *upstreamPort, *upstreamTLS, *publishClusterID) if *hstsMaxAge != 0 { server.hstsEnabled = true server.hsts = fmt.Sprintf("max-age=%d", *hstsMaxAge) } // Enable maintenance handling. frontends := []Maintainable{server} handleMaintenance(frontends, *maintenanceMode) // Setup the HTTP Redirector. runRedirector(*redirectorHost, *redirectorPort, *redirectURL, *hstsMaxAge) // Run the Live Server. runHTTP("Live Server", *host, *port, server, "") // Enter the wait loop for the process to be killed. loopForever := make(chan bool, 1) <-loopForever }
func main() { opts := optparse.Parser("Usage: html2domly [options]", "v") outputFile := opts.String([]string{"-o", "--output"}, "../coffee/templates.coffee", "coffeescript file to compile to", "PATH") templatesSrcDir := opts.String([]string{"-i", "--input"}, "../etc/domly", "template source directory", "PATH") printJSON := opts.Bool([]string{"--print"}, false, "Print the JSON nicely to the output logger") os.Args[0] = "html2domly" opts.Parse(os.Args) log.AddConsoleLogger() var ( data []byte err error prettyStr string basename string pretty bytes.Buffer ) dir, err := os.Open(*templatesSrcDir) if err != nil { runtime.StandardError(err) } defer dir.Close() out, err := os.Create(*outputFile) if err != nil { runtime.StandardError(err) } defer out.Close() names, err := dir.Readdirnames(0) if err != nil { runtime.StandardError(err) } out.Write([]byte("define 'templates', (exports, root) ->\n")) for _, name := range names { if strings.HasSuffix(name, ".html") { basename = strings.TrimSuffix(name, ".html") } else { log.Error("file %v does not end in .html", name) continue } templatePath := filepath.Join(*templatesSrcDir, name) data, err = ui.ParseTemplate(templatePath) if err != nil { log.StandardError(err) } else { err := json.Indent(&pretty, data, ">", " ") if err != nil { log.StandardError(err) log.Info("%v", data) } else if *printJSON { prettyStr = pretty.String() pretty.Reset() log.Info("%v", prettyStr) } out.Write([]byte(fmt.Sprintf(" exports['%s'] = `%s`\n", basename, data))) log.Info("compiled '%s'", name) } } out.Write([]byte(" return")) outPath, _ := filepath.Abs(*outputFile) log.Info("compiled domly written to: %v", outPath) log.Wait() }