func main() { flag.Parse() if len(os.Args) < 2 { log.Fatal("Not enough args") } body, err := json.EncodeClientRequest("Rexd.Execute", &service.ExecuteArgs{ Token: "nyraITVmr61ALZNdf9Ye", Name: "deploy_api", Branch: "master", Args: nil, }) if err != nil { log.Fatal(err) } resp, err := http.Post(*apiURL, "application/json", bytes.NewReader(body)) if err != nil { log.Fatal(err) } rb, err := ioutil.ReadAll(resp.Body) if err != nil { log.Fatal(err) } log.Print(string(rb)) }
func main() { flag.Parse() var err error session, err := r.Connect(r.ConnectOpts{ Hosts: strings.Split(*rethinkdbName, ","), Database: *rethinkdbDatabase, }) if err != nil { log.Fatal(err) } goji.Get("/accounts", listAccounts) goji.Post("/accounts", createAccount) goji.Get("/accounts/:id", getAccount) goji.Put("/accounts/:id", updateAccount) goji.Delete("/accounts/:id", deleteAccount) goji.Get("/accounts/:id/tokens", listAccountTokens) goji.Delete("/accounts/:id/tokens", deleteAccountToken) goji.Get("/tokens", listTokens) goji.Post("/tokens", createToken) goji.Get("/tokens/:id", getToken) goji.Put("/tokens/:id", updateToken) goji.Delete("/tokens/:id", deleteToken) goji.Serve() }
func init() { flag.Usage = func() { fmt.Printf("Usage: envconv [options] file [files...]\n\n") flag.PrintDefaults() } version := flag.Bool("v", false, "Prints current version") flag.Parse() if *version { fmt.Println("envconf version " + VERSION) os.Exit(0) } templateFuncMap = template.FuncMap{ "default": func(args ...string) string { defer recovery() if len(args) <= 0 { return "" } return args[len(args)-1] }, "in": func(arg string, slice []string) bool { defer recovery() for _, i := range slice { if arg == i { return true } } return false }, } }
func main() { log.SetFlags(log.LstdFlags | log.Lshortfile) flag.Parse() // Connect to RethinkDB var err error session, err = r.Connect(r.ConnectOpts{ Address: *rethinkAddress, }) if err != nil { log.Fatal(err) } // Create the database and tables r.DbCreate(*rethinkName).Exec(session) r.Db(*rethinkName).TableCreate("invites").Exec(session) r.Db(*rethinkName).Table("invites").IndexCreate("email").Exec(session) r.Db(*rethinkName).Table("invites").IndexCreate("name").Exec(session) // Add a CORS middleware goji.Use(cors.New(cors.Options{ AllowCredentials: true, }).Handler) // Add routes to goji goji.Get("/", index) goji.Post("/check", check) goji.Post("/free", free) goji.Post("/create", create) // Start the server goji.Serve() }
func main() { flag.Parse() f := finch.NewFinch(*apiToken) f.Start() }
func main() { flag.Parse() conn, err := common.Connect() if err != nil { panic(err) } uplink = conn conn.Subscribe(uplink.ID+":input", func(subj, unusedReply string, msg *common.Message) { if msg.Kind != "TextMessage" { return } if !strings.HasPrefix(msg.Body, ";source") { return } reply := &common.Message{ Destination: msg.ReplyTo, Kind: "TextMessage", Body: "Source code: https://github.com/Xe/betterbot", } conn.Publish(msg.Via+":input", reply) }) conn.Publish("betterbot.birth", &common.Birth{ ID: uplink.ID, EventKinds: []string{"TextMessage"}, }) runtime.Goexit() }
// Serve starts Goji using reasonable defaults. func Serve() { if !flag.Parsed() { flag.Parse() } DefaultMux.Compile() // Install our handler at the root of the standard net/http default mux. // This allows packages like expvar to continue working as expected. http.Handle("/", DefaultMux) listener := bind.Default() log.Println("Starting Goji on", listener.Addr()) graceful.HandleSignals() bind.Ready() graceful.PreHook(func() { log.Printf("Goji received signal, gracefully stopping") }) graceful.PostHook(func() { log.Printf("Goji stopped") }) err := graceful.Serve(listener, http.DefaultServeMux) if err != nil { log.Fatal(err) } graceful.Wait() }
func main() { flag.Parse() runtime.GOMAXPROCS(numCPU) file, err := os.Open(crontabPath) if err != nil { log.Fatalf("crontab path:%v err:%v", crontabPath, err) } parser, err := NewParser(file) if err != nil { log.Fatalf("Parser read err:%v", err) } runner, err := parser.Parse() if err != nil { log.Fatalf("Parser parse err:%v", err) } file.Close() var wg sync.WaitGroup shutdown(runner, &wg) runner.Start() wg.Add(1) wg.Wait() log.Println("End cron") }
func main() { flag.Parse() session, err := r.Connect(r.ConnectOpts{ Address: *rethinkdbAddress, Database: *rethinkdbDatabase, }) if err != nil { log.Fatal(err) } r.DB(*rethinkdbDatabase).TableCreate("scripts").Exec(session) r.DB(*rethinkdbDatabase).TableCreate("tokens").Exec(session) s := rpc.NewServer() s.RegisterCodec(json.NewCodec(), "application/json") s.RegisterService(&service.Service{ Session: session, }, "Rexd") http.Handle("/rpc", s) http.HandleFunc("/", func(w http.ResponseWriter, req *http.Request) { w.Write([]byte("lavab/rexd 0.1.0\n")) }) log.Printf("Binding to %s", *bindAddress) if err := http.ListenAndServe(*bindAddress, nil); err != nil { log.Fatal(err) } }
func main() { flag.Parse() addr := Host + ":" + Port logger.Info("botyardq", "path", DBPath, "host", Host, "port", Port) broker = NewBroker(DBPath) err := broker.Init() if err != nil { logger.Error("broker", "err", err) os.Exit(1) } router := httprouter.New() router.POST("/v1/queues/:queue", PushHandler) router.GET("/v1/queues/:queue", PopHandler) router.DELETE("/v1/queues/:queue/:id", DeleteHandler) logger.Info("Serving at " + addr) err = http.ListenAndServe(addr, router) if err != nil { log.Error("listen", "err", err) os.Exit(1) } logger.Info("bye") }
func init() { rand.Seed(time.Now().Unix()) rethinkdbHost = flag.String("rethinkdb_host", "localhost", "RethinkDB hostname or IP") rethinkdbPort = flag.String("rethinkdb_port", "28015", "Port to connect to RethinkDB") env = flag.String("env", "dev", "Application environment - dev/staging/prod") tmpTable = flag.String("tmp_table", "tmp_"+uniuri.New(), "Table to save temporary results") flag.Parse() }
func main() { flag.Parse() log = logrus.New() if *logFormatterType == "text" { log.Formatter = &logrus.TextFormatter{ ForceColors: *logForceColors, } } else if *logFormatterType == "json" { log.Formatter = &logrus.JSONFormatter{} } log.Level = logrus.DebugLevel if *enableHub || *enableSender { var err error session, err = r.Connect(r.ConnectOpts{ Address: *rethinkdbAddress, }) if err != nil { log.WithField("error", err.Error()).Fatal("Unable to connect to RethinkDB") } r.DbCreate(*rethinkdbDatabase).Exec(session) r.Db(*rethinkdbDatabase).TableCreate("templates").Exec(session) r.Db(*rethinkdbDatabase).Table("templates").IndexCreate("name").Exec(session) r.Db(*rethinkdbDatabase).Table("templates").IndexCreate("version").Exec(session) r.Db(*rethinkdbDatabase).TableCreate("hub_state").Exec(session) r.Db(*rethinkdbDatabase).Table("hub_state").IndexCreate("time").Exec(session) } up := strings.Split(*usernames, ",") pp := strings.Split(*passwords, ",") if len(up) != len(pp) { log.Fatal("length of usernames and passwords is different") } if *enableSender { go initTemplates() for i, username := range up { go initSender(username, pp[i]) } } if *enableHub { change := make(chan struct{}) go initChurner(change) go initHub(change) } select {} }
func main() { flag.Parse() router := router.Create(port, env) // loggedRouter := handlers.LoggingHandler(os.Stdout, router) startApp() fmt.Printf("Running on port: %+v \n", port) fmt.Printf("Environment: %+v \n", env) log.Fatal(http.ListenAndServe(":"+port, router)) }
func main() { flag.Parse() conn, err := common.Connect() if err != nil { panic(err) } uplink = conn conn.Subscribe(uplink.ID+":input", func(subj, unusedReply string, msg *common.Message) { if msg.Kind != "TextMessage" { return } reply := &common.Message{ Destination: msg.ReplyTo, Kind: "TextMessage", } switch msg.Body { case ";np": body, err := np() if err != nil { reply.Body = err.Error() } else { reply.Body = body } case ";dj": body, err := dj() if err != nil { reply.Body = err.Error() } else { reply.Body = body } case ";stats": body, err := stats() if err != nil { reply.Body = err.Error() } else { reply.Body = body } } conn.Publish(msg.Via+":input", reply) }) conn.Publish("betterbot.birth", &common.Birth{ ID: uplink.ID, EventKinds: []string{"TextMessage"}, }) runtime.Goexit() }
func main() { flag.Parse() if !actions.validAction(*action) { fmt.Println("Please choose a valid action. Available: " + actions.available()) os.Exit(1) } err := actions.perform(*action) if err != nil { fmt.Printf("Error performing %s: %v", *action, err) } }
func main() { runtime.GOMAXPROCS(runtime.NumCPU() * 4) flag.BoolVar(&printf, "printf", false, "print replies") flag.BoolVar(&compress, "compress", false, "compress replies") flag.StringVar(&tsig, "tsig", "", "use MD5 hmac tsig: keyname:base64") flag.StringVar(&config, "config", "", "alternative configuration file") flag.StringVar(&bind_addr, "bind_addr", "127.0.0.1:53", "bind HTTP to HOST and PORT") flag.StringVar(&dnsfwd_addr, "dnsfwd_addr", "8.8.8.8:53", "DNS server to forward request to") flag.StringVar(&redis_addr, "redis_addr", "127.0.0.1:6379", "address of Redis instance") flag.StringVar(&portal_addr, "portal_addr", "127.0.0.1:80", "address of portal") flag.StringVar(&log_file, "log_file", "", "path to log file") var name, secret string flag.Usage = func() { flag.PrintDefaults() } flag.Parse() // Setup Log file if len(log_file) > 0 { f, err := os.OpenFile(log_file, os.O_RDWR|os.O_CREATE|os.O_APPEND, 0640) defer f.Close() if err != nil { log.Fatalf("Error opening file: %v", err) } log.SetOutput(f) } // Tsig if tsig != "" { a := strings.SplitN(tsig, ":", 2) name, secret = dns.Fqdn(a[0]), a[1] // fqdn the name, which everybody forgets... } // DNS dns.HandleFunc(".", handleAll) go serve("tcp", name, secret) go serve("udp", name, secret) log.Printf("* Running on %s\n", bind_addr) sig := make(chan os.Signal) signal.Notify(sig, syscall.SIGINT, syscall.SIGTERM) forever: for { select { case s := <-sig: fmt.Printf("Signal (%d) received, stopping\n", s) break forever } } }
func main() { proxyUriPtr := flag.String("proxy-url", "", "uri to listen on eg: http://proxy.com") originUriPtr := flag.String("origin-url", "", "origin to proxy eg: http://origin.com") ssoSecretPtr := flag.String("sso-secret", "", "SSO secret for origin") ssoUriPtr := flag.String("sso-url", "", "SSO endpoint eg: http://discourse.forum.com") flag.Parse() originUrl, err := url.Parse(*originUriPtr) if err != nil { flag.Usage() log.Fatal("invalid origin url") } _, err = url.Parse(*ssoUriPtr) if err != nil { flag.Usage() log.Fatal("invalid sso url, should point at Discourse site with enable sso") } proxyUrl, err2 := url.Parse(*proxyUriPtr) if err2 != nil { flag.Usage() log.Fatal("invalid proxy uri") } if *proxyUriPtr == "" || *originUriPtr == "" || *ssoSecretPtr == "" || *ssoUriPtr == "" { flag.Usage() os.Exit(1) return } cookieSecret := uuid.New() proxy := httputil.NewSingleHostReverseProxy(originUrl) handler := redirectIfCookieMissing(proxy, *ssoSecretPtr, cookieSecret, *ssoUriPtr) server := &http.Server{ Addr: proxyUrl.Host, Handler: handler, ReadTimeout: 10 * time.Second, WriteTimeout: 10 * time.Second, MaxHeaderBytes: 1 << 20, } log.Fatal(server.ListenAndServe()) }
func main() { flag.Parse() router := mux.NewRouter() db := initDB() ctx := util.NewContext(router, db) initRoutes(ctx) seedDB(ctx) addStaticRoute(router) startHTTPServer(router) }
func init() { flag.IntVar(&WebPort, "web-port", 8080, "Port to bind to") flag.StringVar(&EndPointURL, "endpoint", "http://*****:*****@getfishtank.ca", "SMTP username") flag.StringVar(&SmtpPassword, "smtp-password", "", "SMTP password") flag.StringVar(&DatabaseStore, "database", "mongodb://127.0.0.1:27017/model", "database") flag.StringVar(&GplusKey, "gplus-key", "1049113770955-agedcvcoi68qlbc9mm321odb5qdqlgrg.apps.googleusercontent.com", "Google+ OAuth Key") flag.StringVar(&GplusSecret, "gplus-secret", "TjdRDltddkFtlx9dyStuaa5w", "Google+ OAuth Secret") flag.StringVar(&FacebookKey, "facebook-key", "1667094910175363", "facebook key") flag.StringVar(&FacebookSecret, "facebook-secret", "63472dc2deb3269d298f529cc727b9f2", "facebook secret") flag.StringVar(&TwitterKey, "twitter-key", "QVO8QAPqpvnfX6CY3291GkauQ", "twitter key") flag.StringVar(&TwitterSecret, "twitter-secret", "YpaY8TsSR2aLOJh4o9XIqXSgtRubhACmRI2oWTPJs608hdJYv9", "twitter secret") flag.Parse() log.Printf("Config file %s", config) log.Printf("Web folder %s", StaticAssets) log.Printf("Web host %s", WebHost) log.Printf("Web port %s", WebPort) log.Printf("End point %s", EndPointURL) log.Printf("Use SSL %s", UseSSL) log.Printf("certification file %s", CertFile) log.Printf("key file %s", KeyFile) log.Printf("run folder %s", RunFolder) log.Printf("template folder %s", TemplateFolder) log.Printf("end point %s", EndPointURL) log.Printf("SMTP host %s", SmtpHost) log.Printf("SMTP port %s", SmtpPort) log.Printf("SMTP username %s", SmtpUsername) log.Printf("SMTP password %s", SmtpPassword) log.Printf("Database %s", DatabaseStore) log.Printf("JWT File %s", JwtFile) log.Printf("Google plus %s", GplusKey) log.Printf("Google Secret %s", GplusSecret) log.Printf("facebook %s", FacebookKey) log.Printf("facebook secret %s", FacebookSecret) log.Printf("twitter %s", TwitterKey) log.Printf("twitter secret %s", TwitterSecret) }
func main() { flag.Parse() conn, err := common.Connect() if err != nil { panic(err) } uplink = conn bot := irc.IRC(*ircNick, *ircUser) bot.UseTLS = *ircServerSSL bot.AddCallback("*", func(event *irc.Event) { msg := eventToMessage(event) uplink.Printf("Recieved %q (%s)", msg.Kind, event.Raw) uplink.Publish("betterbot.input", msg) }) bot.AddCallback("001", func(e *irc.Event) { for _, channel := range strings.Split(*ircChannels, ",") { bot.Join(channel) } }) conn.Subscribe(uplink.ID+":input", func(subj, reply string, msg *common.Message) { kind := "" if strings.HasPrefix(msg.Kind, "irc:") { kind = strings.TrimPrefix(msg.Kind, "irc:") } else { for key, value := range verbKind { if value == msg.Kind { kind = key break } } } bot.SendRawf("%s %s :%s", kind, msg.Destination, msg.Body) }) err = bot.Connect(*ircServer) if err != nil { panic(err) } runtime.Goexit() }
func init() { flag.StringVar(&host, "host", "127.0.0.1", "host to bind to") flag.IntVar(&port, "port", 2121, "port to bind to") flag.StringVar(&username, "ftp-username", "ftp2s3", "FTP username") flag.StringVar(&password, "ftp-password", "ftp2s3", "FTP password") flag.StringVar(&serverName, "ftp-server-name", "FTP2S3", "FTP server name") flag.StringVar(&awsRegion, "aws-region", "us-east-1", "AWS region") flag.StringVar(&awsAccessKeyID, "aws-access-key-id", "", "AWS access key ID") flag.StringVar(&awsSecretAccessKey, "aws-secret-access-key", "", "AWS secret access key") flag.StringVar(&awsBucketName, "aws-bucket-name", "", "S3 bucket name") flag.String("config", "", "path to config file") flag.Parse() }
func main() { flag.Parse() pool = newPool(*redisServer) conn, err := common.Connect() if err != nil { panic(err) } uplink = conn conn.QueueSubscribe("betterbot.birth", "router", subBirth) conn.QueueSubscribe("betterbot.input", "router", subInput) runtime.Goexit() }
func NewSettings(version, home string, locations []string) (*Settings, error) { location := searchConfig(locations) if location == "" { msg := "Unable to find mediagui.conf\nIt should be placed at any these locations:\n$HOME/.mediagui/\n/usr/local/etc\n<app directory>" return nil, errors.New(msg) } var config, dataDir, webDir, logDir, mediaFolders, ginMode, cpuprofile, unraidHosts string var logtostderr, unraidMode bool flag.BoolVar(&logtostderr, "logtostderr", true, "true/false log to stderr") flag.StringVar(&config, "config", "", "config location") flag.StringVar(&dataDir, "datadir", filepath.Join(home, ".mediagui/db"), "folder containing the database files") flag.StringVar(&webDir, "webdir", filepath.Join(home, ".mediagui/web"), "folder where web app will be read from") flag.StringVar(&logDir, "logdir", "", "folder where log file will be written to") flag.StringVar(&mediaFolders, "mediafolders", "/mnt/user/films", "folders that will be scanned for media") flag.StringVar(&ginMode, "gin_mode", "release", "gin mode") flag.StringVar(&cpuprofile, "cpuprofile", "", "write cpu profile to file") flag.BoolVar(&unraidMode, "unraid_mode", true, "if true the app will work distributed with a service running on the unraid host") flag.StringVar(&unraidHosts, unraidHosts, "wopr|hal", "specify which unraid hosts will be scanned for movies. the service agent must be running in that host") flag.Set("config", location) flag.Parse() // fmt.Printf("mediaFolders: %s\n", mediaFolders) s := &Settings{} if mediaFolders == "" { s.MediaFolders = make([]string, 0) } else { s.MediaFolders = strings.Split(mediaFolders, "|") } s.Version = version s.DataDir = dataDir s.WebDir = webDir s.LogDir = logDir s.Location = location s.GinMode = ginMode s.CpuProfile = cpuprofile s.UnraidMode = unraidMode if unraidHosts == "" { s.UnraidHosts = make([]string, 0) } else { s.UnraidHosts = strings.Split(unraidHosts, "|") } return s, nil }
func main() { flag.Parse() conn, err := common.Connect() if err != nil { panic(err) } uplink = conn conn.Subscribe(uplink.ID+":input", func(subj, unusedReply string, msg *common.Message) { if msg.Kind != "TextMessage" { return } if strings.HasPrefix(msg.Body, ";") { return } reply := &common.Message{ Destination: msg.ReplyTo, Kind: "TextMessage", } var replyMsg string var err error if strings.Contains(msg.Body, "animate me") { replyMsg, err = giphySearch(helperExtractTerms("animate me", msg.Body)) } else if strings.Contains(msg.Body, "image me") { replyMsg, err = imageMe(helperExtractTerms("image me", msg.Body), msg.Sender) } if err != nil { reply.Body = err.Error() } else { reply.Body = replyMsg } conn.Publish(msg.Via+":input", reply) }) conn.Publish("betterbot.birth", &common.Birth{ ID: uplink.ID, EventKinds: []string{"TextMessage"}, }) runtime.Goexit() }
func main() { var ( rootDir string assetPath string srvPath string ui string ) flag.StringVar(&rootDir, "root-dir", "/home/vagrant/go/src/github.com/bentrevor/calhoun", "project root") flag.StringVar(&assetPath, "asset-path", "web/assets", "asset path") flag.StringVar(&srvPath, "srv-path", fmt.Sprintf("%s/images/srv", assetPath), "path to save uploaded files") flag.StringVar(&ui, "ui", "web", "") flag.Parse() var server app.CalhounServer postgresDB := db.NewPostgresDB("dev") realFS := db.RealFS{RootDir: srvPath} store := app.CalhounStore{DB: postgresDB, FS: realFS, SrvPath: srvPath} calhoun := app.Calhoun{Store: store} switch ui { case "web": calhoun.Renderer = web.BrowserRenderer{ ViewsPath: fmt.Sprintf("%s/web/views", rootDir), PhotosPath: srvPath, } server = &web.WebServer{ App: calhoun, AssetPath: assetPath, FullAssetPath: fmt.Sprintf("%s/%s", rootDir, assetPath), } case "cli": calhoun.Renderer = cli.ConsoleRenderer{} server = cli.ConsoleServer{ App: calhoun, Args: flag.Args(), } default: log.Fatal(ui, " not supported") } app.Run("dev", server) }
func main() { // Parse the flags flag.Parse() // Ensure that admin token and commit are set if *token == "" || *commit == "" { log.Fatal("Invalid arguments") } // Try to load all files files := map[string]string{} for _, path := range flag.Args() { data, err := ioutil.ReadFile(path) if err != nil { log.Fatal(err) } files[path] = string(data) } // JSON-encode the files input, err := json.Marshal(&files) if err != nil { log.Fatal(err) } // Send it to the API req, err := http.NewRequest("POST", *apiURL+"/maps/"+*commit, bytes.NewReader(input)) if err != nil { log.Fatal(err) } req.Header.Set("Content-Type", "application/json; charset=utf-8") req.Header.Set("Authorization", "Bearer "+*token) resp, err := http.DefaultClient.Do(req) if err != nil { log.Fatal(err) } // Write the result body, err := ioutil.ReadAll(resp.Body) if err != nil { log.Fatal(err) } log.Printf("%d: %s", resp.StatusCode, string(body)) }
func main() { flag.Parse() fmt.Println("Weather-service params, for more info use -help option:") fmt.Println("\t-Port: " + port) fmt.Println("\t-openweather app id: " + openWeatherAppId) fmt.Println("Bootstrapping system...") forecastInteractor := new(usecases.ForecastInteractor) forecastInteractor.ForecastRepository = interfaces.NewRestForecastRepo(&http.Client{}, openWeatherAppId) webserviceHandler := interfaces.WebserviceHandler{} webserviceHandler.ForecastInteractor = forecastInteractor mux := routes.New() mux.Get("/forecast", webserviceHandler.GetForecast) http.Handle("/", mux) fmt.Println("Bootstrapping web service...") log.Fatal(http.ListenAndServe(":"+port, nil)) }
func main() { flag.Parse() s := syslog.NewServer() s.AddHandler(newHandler()) err := s.Listen(*bind) if err != nil { log.Fatal(err) } log.Printf("Listening to %s", *bind) sc := make(chan os.Signal, 2) signal.Notify(sc, syscall.SIGTERM, syscall.SIGINT) <-sc log.Print("Shutdown the server...") s.Shutdown() log.Print("Server is down") }
func main() { flag.Parse() conn, err := common.Connect() if err != nil { panic(err) } uplink = conn conn.Subscribe(uplink.ID+":input", func(subj, unusedReply string, msg *common.Message) { if msg.Kind != "TextMessage" { return } if !strings.HasPrefix(msg.Body, ";printerfact") { return } reply := &common.Message{ Destination: msg.ReplyTo, Kind: "TextMessage", } fact, err := getPrinterFact() if err != nil { reply.Body = err.Error() return } else { reply.Body = fact } conn.Publish(msg.Via+":input", reply) }) conn.Publish("betterbot.birth", &common.Birth{ ID: uplink.ID, EventKinds: []string{"TextMessage"}, }) runtime.Goexit() }
func main() { var ( config string length float64 age int name string female bool ) flag.StringVar(&config, "config", "", "help message") flag.StringVar(&name, "name", "", "help message") flag.IntVar(&age, "age", 0, "help message") flag.Float64Var(&length, "length", 0, "help message") flag.BoolVar(&female, "female", false, "help message") flag.Parse() fmt.Println("length:", length) fmt.Println("age:", age) fmt.Println("name:", name) fmt.Println("female:", female) }