func main() { kingpin.Version(fmt.Sprintf("%s %s", kingpin.CommandLine.Name, version)) kingpin.Parse() level, err := oplogging.LogLevel(*loglevel) if err != nil { prefixedUserError("Bad loglevel: %s", loglevel) os.Exit(1) } logging.SetLevel(level) diffCmd, err := shellwords.NewParser().Parse(*diffCommand) if err != nil { userError("Error parsing diff command %q: %s", *diffCommand, err.Error()) os.Exit(1) } tests, err := testcase.DiscoverTests(*testcasePath) if err != nil { userError(err.Error()) os.Exit(1) } if err = runTests(*logstashPath, tests, *configPaths, diffCmd, *keptEnvVars); err != nil { userError(err.Error()) os.Exit(1) } os.Exit(0) }
func main() { logger := log.New(os.Stdout, "logger: ", log.Lshortfile) kingpin.Parse() filechannel := make(chan string, 100) go pump.TailFile(filechannel, *filename) mainpage := &frontend.MainPage{HTTPSMode: false, BasicAuth: false, UserName: *user, UserPassword: *password} if *user != "" && *password != "" { mainpage.BasicAuth = true } if *cert != "" && *key != "" { mainpage.HTTPSMode = true } logger.Printf("Basic auth: %t", mainpage.BasicAuth) logger.Printf("HTTPS: %t", mainpage.HTTPSMode) handler := pump.WebHandler{Filechannel: filechannel, Buffer: make([]string, *number), BufferSize: *number} address := fmt.Sprintf("%s:%d", *host, *port) r := mux.NewRouter() r.Handle("/", mainpage) r.Handle("/socket", websocket.Handler(handler.Websocket)) http.Handle("/static/", http.StripPrefix("/static/", http.FileServer(assetFS()))) http.Handle("/", r) logger.Printf("Listening on %s\n", address) if *cert != "" && *key != "" { http.ListenAndServeTLS(address, *cert, *key, nil) } http.ListenAndServe(address, nil) }
func main() { kingpin.Version(Version) kingpin.Parse() setupLoggo(*debug) //localRegistry := metrics.NewRegistry() //publisher := newPublisher(localRegistry) //publisher := newLitePublisher() mqttEngine, mqerr := newMqttEngine(*mqttURL) wbEngine, wberr := NewWebBrickDriver(mqttEngine) if mqerr != nil && wberr != nil { panic(err) } wbEngine.Start() //ws := newWsServer(localRegistry) //go ws.listenAndServ(*port, *path) // Set up channel on which to send signal notifications. sigc := make(chan os.Signal, 1) signal.Notify(sigc, os.Interrupt, os.Kill) // Wait for receiving a signal. <-sigc // Disconnect the Network Connection. if err := engine.disconnect(); err != nil { panic(err) } }
func init() { //set logging logg.LogKeys[TagError] = true logg.LogKeys[TagDiff] = true if DEBUG == false { logg.LogKeys[TagLog] = true } kingpin.Parse() if *configFileName == "" { kingpin.Errorf("Config file name missing") return } configFile, err := os.Open(*configFileName) if err != nil { logg.LogPanic("Unable to open file: %v. Err: %v", *configFileName, err.Error()) return } defer configFile.Close() configReader := bufio.NewReader(configFile) err = parseConfigFile(configReader) if err != nil { logg.LogPanic("Erro parsing the config file: %v", err) } }
func main() { //Parse command line flags var ( _host = kingpin.Flag("host", "Hostname").Short('h').Required().String() _port = kingpin.Flag("port", "Port number").Short('p').Required().Int() _threads = kingpin.Flag("threads", "Thread count").Short('t').Default("1").Int() _size = kingpin.Flag("size", "Packet Size").Short('s').Default("65507").Int() ) kingpin.Parse() fullAddr := fmt.Sprintf("%s:%v", *_host, *_port) //Create send buffer var buf []byte = make([]byte, *_size) //Establish udp conn, err := net.Dial("udp", fullAddr) if err != nil { fmt.Println(err) } else { fmt.Printf("Flooding %s\n", fullAddr) for i := 0; i < *_threads; i++ { go func() { for { conn.Write(buf) } }() } } //Sleep forever <-make(chan bool, 1) }
func main() { kingpin.Parse() if *train { println("START") start := time.Now().UnixNano() ptrain := NewHMMParser("training/training.set") println("Training set loaded") ptrain.fParseTrainer() println("Training set trained") ptrain.Save() stop := time.Now().UnixNano() println("training delta", (stop-start)/1000, "mics") } else { println("Loading model " + *model) hmmParser := NewHMMParser(*model) hmmParser.Load() hmm := NewHMM(hmmParser) println("Model " + *model + " loaded") start := time.Now().UnixNano() ws := strings.Split("<s> "+*text, " ") hmm.fViterbi(ws) println(hmm.String()) stop := time.Now().UnixNano() println("test delta", (stop-start)/1000, "mics") } }
func main() { kingpin.Parse() u, err := user.Lookup(*cliChownUser) if err != nil { panic(err) } g, err := user.Lookup(*cliChownGroup) if err != nil { panic(err) } uid, err = strconv.Atoi(u.Uid) if err != nil { panic(err) } gid, err = strconv.Atoi(g.Gid) if err != nil { panic(err) } // Ensure all folders and files are currently set to the correct permissions. filepath.Walk(*cliDir, update) // Now we will wait for watch(*cliDir) }
func main() { var ( bcontent []byte content string err error ) kingpin.Parse() if strings.HasPrefix(*infile, "wikipedia:") { log.Println("Fetching from wikipedia:", strings.TrimPrefix(*infile, "wikiedia:")) content, err = scrapedia.GetMainText("https://en.wikipedia.org/wiki/" + strings.TrimPrefix(*infile, "wikipedia:")) } else { // Default: assume plaintext file and load contents. log.Println("Opening plaintext file: " + *infile) bcontent, err = ioutil.ReadFile(*infile) content = string(bcontent) } if err != nil { log.Fatal(err.Error()) } log.Println("Beginning at", *wpm, "words per minute..") took_seconds, total_wds, final_wpm, err := spritzlib.RenderSpritzed(string(content), *wpm, *boldText, colourNameToCode(*pivotColour), colourNameToCode(*plainColour), colourNameToCode(*bgColour)) if err != nil { log.Fatal(err.Error()) } log.Println("Finished reading", total_wds, "words in", took_seconds, "seconds") log.Println("Final wpm:", final_wpm) }
func main() { var err error kingpin.Parse() parsed, err := parseFile(*inputFile) fatalError(err) writer := NewAgentWriter(*interfaceName, *packageName, parsed) var out io.Writer if *outputFile == "" { out = os.Stdout } else { out, err = os.Create(*outputFile) fatalError(err) } WriteCodeGenerationWarning(out) writer.WritePackageName(out) WriteLibImport(out) writer.WriteAgentType(out) writer.WriteAgentMethods(out) writer.WriteAgentControl(out) writer.WriteRunLoop(out) for _, constructor := range *constructors { writer.WriteConstructor(out, constructor) } }
func main() { // Setup context ctx, cancel := context.WithCancel(context.Background()) defer cancel() // Define a CLI dcConfig := &DCConfig{ServiceIdentifier: "omnivore"} kingpin.Flag("n", "The index of this node in the pool, if IPFS_POOL_PATH is set").Default("-1").Short('n').IntVar(&dcConfig.PoolIndex) var args []string kingpin.Arg("args", "arguments").StringsVar(&args) kingpin.Parse() // Build a node ipfsNode, err := BuildNode(ctx, dcConfig) if err != nil { fmt.Println(err) os.Exit(1) } fmt.Printf("I am node %s\n", ipfsNode.Identity.Pretty()) // Respond to incoming providerIDs and streams // providerIDsIn, err := StartServiceDiscovery(ctx, ipfsNode, dcConfig) // if err != nil { // fmt.Println(err) // os.Exit(1) // } // // streamIn, err := StartListening(ipfsNode, dcConfig) // if err != nil { // fmt.Println(err) // os.Exit(1) // } // // for { // select { // case providerIDs := <-providerIDsIn: // for _, providerID := range providerIDs { // fmt.Printf("Provider: %s\n", providerID.Pretty()) // // stream, err := corenet.Dial(ipfsNode, providerID, dcConfig.ServiceIdentifier) // if err != nil { // fmt.Printf("Failed to dial provider %s (%s)\n", providerID.Pretty(), err) // continue // } // // fmt.Fprintf(stream, "Hello! I'm peer %s\n", ipfsNode.Identity.Pretty()) // stream.Close() // } // // case stream := <-streamIn: // fmt.Printf("Peer %s called!\n", stream.Conn().RemotePeer().Pretty()) // } // } }
func main() { kingpin.CommandLine.Help = "An example implementation of curl." switch kingpin.Parse() { case "get": kingpin.FatalIfError(apply("GET", (*getURL).String()), "GET failed") case "post": kingpin.FatalIfError(applyPOST(), "POST failed") } }
func main() { kingpin.UsageTemplate(kingpin.CompactUsageTemplate).Version("1.0").Author("Alec Thomas") kingpin.CommandLine.Help = "An example implementation of curl." switch kingpin.Parse() { case "get url": kingpin.FatalIfError(apply("GET", (*getURLURL).String()), "GET failed") case "post": kingpin.FatalIfError(applyPOST(), "POST failed") } }
func main() { kingpin.Parse() config, err := config.LoadConfiguration(*configurationPath) if err != nil { log.Fatal(err) } youppi := slackscot.NewSlackscot([]slackscot.ExtentionBundle{brain.NewKarma(), brain.NewImager()}) slackscot.Run(*youppi, *config) }
func main() { kingpin.Version("0.2.1") kingpin.Parse() switch *format { case "html": openBrowser() case "json": fetchJSON() default: openBrowser() } }
func main() { kingpin.CommandLine.Help = "Docker container EC2 metadata service." kingpin.Parse() defer log.Flush() configureLogging(*verboseOpt) auth, err := aws.GetAuth("", "", "", time.Time{}) if err != nil { panic(err) } containerService := NewContainerService(dockerClient(), *defaultRole, auth) // Proxy non-credentials requests to primary metadata service http.HandleFunc("/", logHandler(func(w http.ResponseWriter, r *http.Request) { match := credsRegex.FindStringSubmatch(r.URL.Path) if match != nil { handleCredentials(match[1], match[2], containerService, w, r) return } proxyReq, err := http.NewRequest(r.Method, fmt.Sprintf("%s%s", baseUrl, r.URL.Path), r.Body) if err != nil { log.Error("Error creating proxy http request: ", err) http.Error(w, "An unexpected error occurred communicating with Amazon", http.StatusInternalServerError) return } copyHeaders(proxyReq.Header, r.Header) resp, err := instanceServiceClient.RoundTrip(proxyReq) if err != nil { log.Error("Error forwarding request to EC2 metadata service: ", err) http.Error(w, "An unexpected error occurred communicating with Amazon", http.StatusInternalServerError) return } defer resp.Body.Close() copyHeaders(w.Header(), resp.Header) w.WriteHeader(resp.StatusCode) if _, err := io.Copy(w, resp.Body); err != nil { log.Warn("Error copying response content from EC2 metadata service: ", err) } })) log.Critical(http.ListenAndServe(*serverAddr, nil)) }
func main() { kingpin.Version("0.1") kingpin.Parse() f, err := os.OpenFile(*logfile, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0666) if err != nil { panic(err) } defer f.Close() LogInit(f) GetClusterReport(*conf) }
func main() { kingpin.Version("0.1") kingpin.Parse() ttyPath := *device fmt.Println("Writing packets to: " + ttyPath) fmt.Println("Packets are formatted all lower case hex, [src] [dest] [message...]") fmt.Println("Quote ascii strings for text conversion") serialConfig := &serial.Config{Name: ttyPath, Baud: 9600, Parity: serial.PARITY_EVEN} port, err := serial.OpenPort(serialConfig) if err != nil { panic(err) } go func() { parser := ibus.NewIbusPacketParser() for { buffer := make([]byte, 1) _, err := port.Read(buffer) if err != nil { panic(err) } parser.Push(buffer) if parser.HasPacket() { pkt := parser.GetPacket() // echo received packets to simulate bus broadcast port.Write(pkt.AsBytes()) fmt.Println("\n<== " + pkt.AsString()) fmt.Print("Enter IBUS packet: ") } } }() for { reader := bufio.NewReader(os.Stdin) fmt.Print("Enter IBUS packet: ") text, _ := reader.ReadString('\n') text = strings.TrimSpace(text) hexChars := strings.Split(text, " ") packet := new(ibus.IbusPacket) packet.Src = hexChars[0] packet.Dest = hexChars[1] packet.Message = hexChars[2:len(hexChars)] fmt.Println("==> " + packet.AsString()) bytes := packet.AsBytes() port.Write(bytes) } }
func main() { bsize := kingpin.Flag("blocksize", "blocksize to test with").Default("262144").Int64() kingpin.Parse() ipfsdir := getIpfsDir() r, err := fsrepo.Open(ipfsdir) if err != nil { fmt.Printf("Failed to open ipfs repo at: %s: %s\n", ipfsdir, err) fmt.Println("Please ensure ipfs has been initialized and that no daemon is running") return } ctx, cancel := context.WithCancel(context.Background()) defer cancel() nd, err := core.NewNode(ctx, &core.BuildCfg{ Repo: r, }) if err != nil { fmt.Printf("failed to create node: %s\n", err) return } cfg := &BenchCfg{ Blocksize: *bsize, } fmt.Println(cfg) err = BenchmarkBlockRewrites(nd, cfg) if err != nil { panic(err) } err = BenchmarkRandomBlockWrites(nd, cfg) if err != nil { panic(err) } err = BenchmarkAdd(nd, cfg) if err != nil { panic(err) } err = BenchmarkDiskWrites(ipfsdir) if err != nil { panic(err) } }
func main() { kingpin.Version("0.1") kingpin.Parse() f, err := os.OpenFile(*logfile, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0666) if err != nil { panic(err) } defer f.Close() LogInit(*verbose, f) osd_sockets, err := filepath.Glob(*osd_sockets) if err != nil { log.Error("No sockets found exiting") } log.Info("Found following sockets", osd_sockets) c := make(chan perf) perfcounters := make([]PerfCounter, len(osd_sockets)) for _, osd_socket := range osd_sockets { go func() { result, err := QueryAdminSocket(osd_socket) if err != nil { log.Fatal("Querying Socket failed with ", err) } c <- perf{*result, err} }() query := <-c if query.error == nil { perfcounters = append(perfcounters, query.PerfCounter) // perf_json, err := json.Marshal(query.PerfCounter) // if err == nil { // fmt.Println(string(perf_json)) // } token, err := get_token() if err == nil { PostPerfCeilometer(token, query.PerfCounter) } } } GetClusterStatus(*conf) GetClusterIOPs(*conf) }
func parseFlags() { kingpin.HelpFlag.Short('h') kingpin.Version(versionMessage()) kingpin.Flag("root", "root directory").Short('r').Default("./").StringVar(&gcfg.Root) kingpin.Flag("addr", "listen address").Short('a').Default(":8000").StringVar(&gcfg.Addr) kingpin.Flag("cert", "tls cert.pem path").StringVar(&gcfg.Cert) kingpin.Flag("key", "tls key.pem path").StringVar(&gcfg.Key) kingpin.Flag("httpauth", "HTTP basic auth (ex: user:pass)").Default("").StringVar(&gcfg.HttpAuth) kingpin.Flag("theme", "web theme, one of <black|green>").Default("black").StringVar(&gcfg.Theme) kingpin.Flag("upload", "enable upload support").BoolVar(&gcfg.Upload) kingpin.Flag("xheaders", "used when behide nginx").BoolVar(&gcfg.XHeaders) kingpin.Flag("cors", "enable cross-site HTTP request").BoolVar(&gcfg.Cors) kingpin.Flag("plistproxy", "plist proxy when server is not https").Default(defaultPlistProxy).Short('p').URLVar(&gcfg.PlistProxy) kingpin.Flag("title", "server title").Default("Go HTTP File Server").StringVar(&gcfg.Title) kingpin.Parse() }
func main() { kingpin.UsageTemplate(kingpin.DefaultUsageTemplate).Author("Cathal Garvey") //kingpin.CommandLine.Help = "miniLock-cli: The miniLock encryption system for terminal/scripted use." switch kingpin.Parse() { case "encrypt": kingpin.FatalIfError(encryptFile(), "Failed to encrypt..") case "decrypt": { kingpin.FatalIfError(decryptFile(), "Failed to decrypt..") } default: { fmt.Println("No subcommand provided..") } } if userKey != nil { userKey.Wipe() } }
func main() { kingpin.Version("1.3") kingpin.Parse() api := slack.New(*token) for { users, _ := api.UsersList() svc := ec2.New(session.New(), &aws.Config{Region: aws.String(*region)}) // Call the DescribeInstances Operation resp, err := svc.DescribeInstances(nil) if err != nil { panic(err) } usersInstances := findLongRunningInstances(resp, users) alreadyNotified := getAlreadyNotified() for user, instances := range usersInstances { msg := "" for _, inst := range instances { if !contains(alreadyNotified, *inst.InstanceId) { msg += fmt.Sprintf("`%v - %v` with id _%v_\n", getTagValue(inst.Tags, "Purpose"), getTagValue(inst.Tags, "Name"), *inst.InstanceId) alreadyNotified = append(alreadyNotified, *inst.InstanceId) } } if msg != "" { msg := "\nYou have the following instances running in amazon:\n\n" + msg msg += "They were all started more then two days ago, are they still needed ?" if user == "U02HSGZ3F" || *prod { // ME err = api.ChatPostMessage(user, msg, &slack.ChatPostMessageOpt{Username: "******"}) } } } saveAlreadyNotified(alreadyNotified) time.Sleep(time.Duration(*timeout) * time.Minute) } }
func init() { // parse config file kingpin.Parse() if *configFileName == "" { kingpin.Errorf("Config file name missing") return } configFile, err := os.Open(*configFileName) if err != nil { logg.LogPanic("Unable to open file: %v. Err: %v", *configFileName, err.Error()) return } defer configFile.Close() configReader := bufio.NewReader(configFile) parseConfigFile(configReader) //set logging logg.LogKeys[logTag] = true }
func main() { kingpin.Parse() initRouters() http.Handle("/", m) addr := ":" + strconv.Itoa(gcfg.port) p := strconv.Itoa(gcfg.port) //mesg := "; please visit http://127.0.0.1:" + p if gcfg.private { addr = "localhost" + addr log.Printf("listens on 127.0.0.1@" + p) // + mesg) } else { log.Printf("listens on 0.0.0.0@" + p) // + mesg) } /* if gcfg.ftp { //log.Println("Enable FTP") auths := strings.SplitN(gcfg.ftpAuth, ":", 2) if len(auths) != 2 { log.Fatal("ftp auth format error") } auth := FTPAuth{auths[0], auths[1]} ftpserv := goftp.NewServer(&goftp.ServerOpts{ Port: gcfg.ftpPort, Factory: posixfs.NewPosixFSFactory(gcfg.root), Auth: &auth, }) go ftpserv.ListenAndServe() } */ var err error if gcfg.key != "" && gcfg.cert != "" { err = http.ListenAndServeTLS(addr, gcfg.cert, gcfg.key, nil) } else { err = http.ListenAndServe(addr, nil) } log.Fatal(err) }
func main() { kingpin.Parse() // This is a scheduled set of tasks which will unmount old directories which // are not being used by container instances. gocron.Every(15).Seconds().Do(Cleanup, *cliRoot) go gocron.Start() // Discovery the region which this instance resides. This will ensure the // EFS Filesystem gets created in the same region as this instance. metadata := ec2metadata.New(&ec2metadata.Config{}) region, err := metadata.Region() if err != nil { panic(err) } // We need to determine which region this host lives in. That will allow us to spin // up EFS Filesystem within this region. e := ec2.New(&aws.Config{Region: aws.String(region)}) i, err := metadata.GetMetadata("instance-id") if err != nil { panic(err) } subnet, err := GetSubnet(e, i) if err != nil { panic(err) } d := DriverEFS{ Root: *cliRoot, Region: region, Subnet: subnet, } h := dkvolume.NewHandler(d) log.Printf("Listening: %s", socketAddress) log.Println(h.ServeUnix("root", socketAddress)) }
func main() { kingpin.Parse() opt := &install.InstallOption{} if *owner != "" { opt.Owner = *owner } if *group != "" { opt.Group = *group } if *mode != "" { m, err := strconv.ParseInt(*mode, 8, 32) if err != nil { fmt.Printf("invalid mode: %s", err) os.Exit(-1) } mode := os.FileMode(m) opt.Mode = &mode } args := *_args if *dir { for _, name := range args { install.InstallDir(name, opt) } return } sources := args[:len(args)-1] dst := args[len(args)-1] if len(sources) > 1 { if err := checkDst(dst); err != nil { fmt.Println(err.Error()) os.Exit(-1) } } installFile(sources, dst, opt) }
func main() { kingpin.CommandLine.Help = "Docket Registry" kingpin.Parse() loc := *location if _, err := os.Stat(loc); os.IsNotExist(err) { os.Mkdir(loc, 0644) } var storeErr error store, storeErr = openStore() if storeErr != nil { log.Fatal("Failed to open data store: %v", storeErr) } deferCloseStore(store) pString := ":" + *port if err := http.ListenAndServe(pString, m); err != nil { log.Fatal(err) } }
func main() { log.SetFormatter(&log.TextFormatter{}) kingpin.CommandLine.DefaultEnvars() kingpin.Parse() var queue lifecycled.Queue // provide a simulated queue for testing if *sqsQueue == simulateQueue { queue = lifecycled.NewSimulatedQueue(*instanceID) } else { queue = lifecycled.NewSQSQueue(*sqsQueue) } if *debug { log.SetLevel(log.DebugLevel) } signals := make(chan os.Signal) // signal.Notify(signals, os.Interrupt, os.Kill) daemon := lifecycled.Daemon{ Queue: queue, AutoScaling: autoscaling.New(session.New()), Handler: *handler, Signals: signals, InstanceID: *instanceID, } err := daemon.Start() if err != nil { log.Error(err.Error()) os.Exit(1) } }
func main() { kingpin.Version("0.0.1") kingpin.Parse() fmt.Printf("Would ping: %s with timeout %s and count %d", *ip, *timeout, *count) }
func main() { kingpin.Parse() var oldBuf string // Create a client which we can use to connect to the remote Kubernetes cluster. config := &client.Config{ Host: *cliMaster, } client, err := client.New(config) if err != nil { fmt.Println(err) os.Exit(1) } // This ensures we don't overwhelm the Kubernetes API. t, err := time.ParseDuration(*cliRefresh) if err != nil { fmt.Println(err) os.Exit(1) } // This is an ongoing process to pull in new services. limiter := time.Tick(t) for { <-limiter // Get the data from the Kubernetes service API. log.Println("Refreshing data...") // This is the object which we will populate with new data. haproxy := Config{ Port: *cliPort, } // Get a list of all the services. svcs, err := client.Services("").List(api.ListOptions{}) if err != nil { log.Warn(err) continue } // Filter the list down to only the services we need. for _, s := range svcs.Items { // Only register services which are being balanced internally. if s.Spec.Type != "LoadBalancer" { log.Printf("Skipped service: %s", s.ObjectMeta.Name) continue } // Ensure we have the "domain" label set. if val, ok := s.ObjectMeta.Labels["domain"]; ok { // Get a list of all the pods and there IPs to add to the HAProxy. pods, err := client.Pods(s.ObjectMeta.Namespace).List(api.ListOptions{LabelSelector: labels.SelectorFromSet(labels.Set(s.Spec.Selector))}) if err != nil { log.Println(err) continue } // Start building the new listener object. l := Listener{ Domain: val, } // Populate the list of pod IPs. for _, p := range pods.Items { if p.Status.Phase != api.PodRunning { continue } l.Servers = append(l.Servers, Server{Name: p.ObjectMeta.Name, Address: p.Status.PodIP + ":80"}) } haproxy.Listeners = append(haproxy.Listeners, l) log.Printf("Added service: %s", s.ObjectMeta.Name) } } // Attempt to rebuild the HAProxy configuration. t := template.Must(template.New("haproxy").Parse(tpl)) buf := new(bytes.Buffer) err = t.Execute(buf, haproxy) if err != nil { log.Warn(err) continue } // Compare buffs. fmt.Println("Current") fmt.Println(buf.String()) fmt.Println("Old") fmt.Println(oldBuf) if buf.String() == oldBuf { log.Warn("Configuration has not changed") continue } // Determine the current running HAProxy process. pid, err := ioutil.ReadFile(*cliPid) if err != nil { log.Warn(err) continue } // Write out the configuration to a file. err = ioutil.WriteFile(*cliConf, buf.Bytes(), 0644) if err != nil { log.Warn(err) continue } // Trigger a reload of the HAProxy service. if err := exec.Command("haproxy", "-f", *cliConf, "-p", *cliPid, "-D", "-sF", string(pid)).Run(); err != nil { log.Warn(err) continue } } }