func main() { fs := flag.NewFlagSet("krud", flag.ExitOnError) listen := fs.String("listen", ":9500", "") deploymentKey := fs.String("deployment-key", "deployment", "Key to use to differentiate between two different controllers.") controllerName := fs.String("controller-name", "", "Name of the replication controller to update.") namespace := fs.String("namespace", api.NamespaceDefault, "Namespace the replication controller.") k8sEndpoint := fs.String("k8s-endpoint", "http://localhost:8080", "URL of the Kubernetes API server") if err := fs.Parse(os.Args[1:]); err != nil { fmt.Fprintln(os.Stderr, err.Error()) os.Exit(1) } if err := flagutil.SetFlagsFromEnv(fs, "KRUD"); err != nil { fmt.Fprintln(os.Stderr, err.Error()) os.Exit(1) } if *deploymentKey == "" || *controllerName == "" { panic("missing deployment key or controller name") } k := &Krud{ DeploymentKey: *deploymentKey, ControllerName: *controllerName, Endpoint: *k8sEndpoint, Namespace: *namespace, } http.HandleFunc("/push", k.push) http.HandleFunc("/", k.view) log.Fatal(k.listen(*listen)) }
func main() { // Github Unauthenticated API client := NewClient(nil) params := &IssueListParams{Sort: "updated"} issues, _, _ := client.IssueService.ListByRepo("golang", "go", params) fmt.Printf("Public golang/go Issues:\n%v\n", issues) // Github OAuth2 API flags := flag.NewFlagSet("github-example", flag.ExitOnError) // -access-token=xxx or GITHUB_ACCESS_TOKEN env var accessToken := flags.String("access-token", "", "Github Access Token") flags.Parse(os.Args[1:]) flagutil.SetFlagsFromEnv(flags, "GITHUB") if *accessToken == "" { log.Fatal("Github Access Token required to list private issues") } config := &oauth2.Config{} token := &oauth2.Token{AccessToken: *accessToken} httpClient := config.Client(oauth2.NoContext, token) client = NewClient(httpClient) issues, _, _ = client.IssueService.List(params) fmt.Printf("Your Github Issues:\n%v\n", issues) // body := &IssueRequest{ // Title: "Test title", // Body: "Some test issue", // } // issue, _, _ := client.IssueService.Create("dghubble", "temp", body) // fmt.Println(issue) }
func main() { // parse flags flags.Parse(os.Args[1:]) flagutil.SetFlagsFromEnv(flags, "LINKERSS") if *accessToken == "" { log.Fatal("Application access token required") } if *defaultNumTweets > *maxNumTweets { log.Fatal("--num-tweets cannot be larger than --max-num-tweets") } // set up the redis pool pool := newPool(*redisServer, *redisPassword) // set up handlers linkerssHandler := linkerss.LinkerssHandler{*accessToken, *defaultNumTweets, *maxNumTweets, pool} http.Handle("/user", linkerssHandler) // log our args before we start listening log.Println("Listening on:" + *listenAddress) log.Println("Default number of tweets:", *defaultNumTweets) log.Println("Maximum number of tweets:", *maxNumTweets) // answer http requests log.Fatal(http.ListenAndServe(*listenAddress, nil)) }
func main() { var mmm mojsql.MojSQL flags := flag.NewFlagSet("trychessserver", flag.ExitOnError) u := flags.String("u", "", "database username") p := flags.String("p", "", "database password") d := flags.String("d", "", "database name") flags.Parse(os.Args[1:]) flagutil.SetFlagsFromEnv(flags, "TRYCHESS") log.Println(u, p, d) log.Println(mmm.Initialize(*u, *p, *d)) sss := mmm.Interface() mul := multi.Multi{sss} mul.Run() }
func main() { flags := flag.NewFlagSet("user-auth", flag.ExitOnError) consumerKey := flags.String("consumer-key", "", "Twitter Consumer Key") consumerSecret := flags.String("consumer-secret", "", "Twitter Consumer Secret") accessToken := flags.String("access-token", "", "Twitter Access Token") accessSecret := flags.String("access-secret", "", "Twitter Access Secret") flags.Parse(os.Args[1:]) flagutil.SetFlagsFromEnv(flags, "TWITTER") if *consumerKey == "" || *consumerSecret == "" || *accessToken == "" || *accessSecret == "" { log.Fatal("Consumer key/secret and Access token/secret required") } config := oauth1.NewConfig(*consumerKey, *consumerSecret) token := oauth1.NewToken(*accessToken, *accessSecret) // OAuth1 http.Client will automatically authorize Requests httpClient := config.Client(oauth1.NoContext, token) // Twitter client client := twitter.NewClient(httpClient) // Verify Credentials verifyParams := &twitter.AccountVerifyParams{ SkipStatus: twitter.Bool(true), IncludeEmail: twitter.Bool(true), } user, _, _ := client.Accounts.VerifyCredentials(verifyParams) fmt.Printf("User's ACCOUNT:\n%+v\n", user) // Home Timeline homeTimelineParams := &twitter.HomeTimelineParams{Count: 2} tweets, _, _ := client.Timelines.HomeTimeline(homeTimelineParams) fmt.Printf("User's HOME TIMELINE:\n%+v\n", tweets) // Mention Timeline mentionTimelineParams := &twitter.MentionTimelineParams{Count: 2} tweets, _, _ = client.Timelines.MentionTimeline(mentionTimelineParams) fmt.Printf("User's MENTION TIMELINE:\n%+v\n", tweets) // Retweets of Me Timeline retweetTimelineParams := &twitter.RetweetsOfMeTimelineParams{Count: 2} tweets, _, _ = client.Timelines.RetweetsOfMeTimeline(retweetTimelineParams) fmt.Printf("User's 'RETWEETS OF ME' TIMELINE:\n%+v\n", tweets) // Update (POST!) Tweet (uncomment to run) // tweet, _, _ := client.Statuses.Update("just setting up my twttr", nil) // fmt.Printf("Posted Tweet\n%v\n", tweet) }
func main() { flags := flag.NewFlagSet("app-auth", flag.ExitOnError) accessToken := flags.String("app-access-token", "", "Twitter Application Access Token") flags.Parse(os.Args[1:]) flagutil.SetFlagsFromEnv(flags, "TWITTER") if *accessToken == "" { log.Fatal("Application Access Token required") } config := &oauth2.Config{} token := &oauth2.Token{AccessToken: *accessToken} // OAuth2 http.Client will automatically authorize Requests httpClient := config.Client(oauth2.NoContext, token) // Twitter client client := twitter.NewClient(httpClient) // user show userShowParams := &twitter.UserShowParams{ScreenName: "golang"} user, _, _ := client.Users.Show(userShowParams) fmt.Printf("USERS SHOW:\n%+v\n", user) // users lookup userLookupParams := &twitter.UserLookupParams{ScreenName: []string{"golang", "gophercon"}} users, _, _ := client.Users.Lookup(userLookupParams) fmt.Printf("USERS LOOKUP:\n%+v\n", users) // status show statusShowParams := &twitter.StatusShowParams{} tweet, _, _ := client.Statuses.Show(584077528026849280, statusShowParams) fmt.Printf("STATUSES SHOW:\n%+v\n", tweet) // statuses lookup statusLookupParams := &twitter.StatusLookupParams{ID: []int64{20}} tweets, _, _ := client.Statuses.Lookup([]int64{573893817000140800}, statusLookupParams) fmt.Printf("STATUSES LOOKUP:\n%+v\n", tweets) // oEmbed status statusOembedParams := &twitter.StatusOEmbedParams{ID: 691076766878691329, MaxWidth: 500} oembed, _, _ := client.Statuses.OEmbed(statusOembedParams) fmt.Printf("OEMBED TWEET:\n%+v\n", oembed) // user timeline userTimelineParams := &twitter.UserTimelineParams{ScreenName: "golang", Count: 2} tweets, _, _ = client.Timelines.UserTimeline(userTimelineParams) fmt.Printf("USER TIMELINE:\n%+v\n", tweets) }
func main() { flags := struct { address string color string version bool help bool }{} flag.StringVar(&flags.address, "address", "127.0.0.1:8080", "HTTP listen address") flag.StringVar(&flags.color, "color", "red", "Background color {blue,green,red}") flag.BoolVar(&flags.version, "version", false, "print version and exit") flag.BoolVar(&flags.help, "help", false, "print usage and exit") // parse command line and environment variable arguments flag.Parse() if err := flagutil.SetFlagsFromEnv(flag.CommandLine, "HELLOGO"); err != nil { log.Fatal(err.Error()) } if flags.version { fmt.Println(version) return } if flags.help { flag.Usage() return } // validate arguments if url, err := url.Parse(flags.address); err != nil || url.String() == "" { log.Fatal("A valid HTTP listen address is required") } if _, ok := colors[flags.color]; !ok { log.Fatalf("Invalid color choice {blue,gree,red}: %s", flags.color) } // random shade rand.Seed(time.Now().UnixNano()) hexColor := colors[flags.color][rand.Intn(numColors)] server := hellogo.New(&hellogo.Config{Color: hexColor}) log.Printf("starting hellogo on %s", flags.address) err := http.ListenAndServe(flags.address, server) if err != nil { log.Fatalf("failed to start listening: %s", err) } }
func main() { var ( auth aws.Auth targetURL url.URL listenAddress string serviceName string region aws.Region ) const flagEnvPrefix = "AWS_AUTH_PROXY" fs := flag.NewFlagSet("aws-auth-proxy", flag.ExitOnError) fs.StringVar(&auth.AccessKey, "access-key", "", "aws access key id") fs.StringVar(&auth.SecretKey, "secret-key", "", "aws secret access key") fs.StringVar(&serviceName, "service-name", "", "aws service name") var regionName string fs.StringVar(®ionName, "region-name", "", "aws region name") fs.StringVar(&targetURL.Host, "upstream-host", "", "host or host:port for upstream endpoint") fs.StringVar(&targetURL.Scheme, "upstream-scheme", "https", "scheme for upstream endpoint") fs.StringVar(&listenAddress, "listen-address", ":8080", "address for proxy to listen on") if err := flagutil.SetFlagsFromEnv(fs, flagEnvPrefix); err != nil { log.Fatal(err) } if len(os.Args) >= 2 && os.Args[1] == "--help" { fs.PrintDefaults() fmt.Printf("\nflagutil prefix is '%s'\n", flagEnvPrefix) fmt.Printf("example:\n\t-access-key=xxx OR export %s_ACCESS_KEY=xxx\n", flagEnvPrefix) os.Exit(0) } fs.Parse(os.Args[1:]) region = aws.GetRegion(regionName) signer := aws.NewV4Signer(auth, serviceName, region) proxyHandler := &AWSProxy{ TargetURL: &targetURL, Signer: signer, } fmt.Printf("Listening on %s\n", listenAddress) log.Fatal(http.ListenAndServe(listenAddress, proxyHandler)) }
func main() { flags := flag.NewFlagSet("user-auth", flag.ExitOnError) consumerKey := flags.String("consumer-key", "", "Twitter Consumer Key") consumerSecret := flags.String("consumer-secret", "", "Twitter Consumer Secret") accessToken := flags.String("access-token", "", "Twitter Access Token") accessSecret := flags.String("access-secret", "", "Twitter Access Secret") flags.Parse(os.Args[1:]) flagutil.SetFlagsFromEnv(flags, "TWITTER") if *consumerKey == "" || *consumerSecret == "" || *accessToken == "" || *accessSecret == "" { log.Fatal("Consumer key/secret and Access token/secret required") } config := oauth1.NewConfig(*consumerKey, *consumerSecret) token := oauth1.NewToken(*accessToken, *accessSecret) // OAuth1 http.Client will automatically authorize Requests httpClient := config.Client(oauth1.NoContext, token) // Twitter Client client := twitter.NewClient(httpClient) // Convenience Demux demultiplexed stream messages // What to do with each type of tweet demux := twitter.NewSwitchDemux() demux.Tweet = func(tweet *twitter.Tweet) { fmt.Println("Pedestrian Down!") fmt.Println(tweet.Text) fmt.Printf("https://twitter.com/%s/status/%s\n", tweet.User.ScreenName, tweet.IDStr) //If not @yyctransport skip if tweet.User.ID != 1729579022 { return } // Determine suffix from number number := 0 body, err := ioutil.ReadFile("/home/ubuntu/peddown/counter.txt") numberString := strings.TrimSpace(string(body)) if err != nil { fmt.Println("counter file does not exist") } else { number, err = strconv.Atoi(numberString) if err != nil { fmt.Println("not a valid string") number = 1 } } number += 1 //Convert number to byte array and save the number numberString = strconv.Itoa(number) body = []byte(numberString) ioutil.WriteFile("/home/ubuntu/peddown/counter.txt", body, 0644) suffix := "th" switch number % 10 { case 1: if (number % 100) != 11 { suffix = "st" } case 2: if (number % 100) != 12 { suffix = "nd" } case 3: if (number % 100) != 13 { suffix = "rd" } } tweetContent := fmt.Sprintf("%d%s tweeted pedestrian incident in 2016.\n#yycwalk #yyccc #ableg #visionzero\n@bmasonndp @shoffmanAB\n\nhttps://twitter.com/yyctransport/status/%s\n", number, suffix, tweet.IDStr) tweet, resp, err := client.Statuses.Update(tweetContent, nil) fmt.Println(resp) fmt.Println(err) } fmt.Println("Starting Stream...") // FILTER filterParams := &twitter.StreamFilterParams{ Track: []string{"ALERT ped,ALERT pedestrian"}, StallWarnings: twitter.Bool(true), } stream, err := client.Streams.Filter(filterParams) if err != nil { log.Fatal(err) } // Receive messages until stopped or stream quits go demux.HandleChan(stream.Messages) // Wait for SIGINT and SIGTERM (HIT CTRL-C) ch := make(chan os.Signal) signal.Notify(ch, syscall.SIGINT, syscall.SIGTERM) log.Println(<-ch) fmt.Println("Stopping Stream...") stream.Stop() }
func main() { // glog will log to tmp files by default. override so all entries // can flow into journald (if running under systemd) flag.Set("logtostderr", "true") // now parse command line args flag.Parse() if flag.NArg() > 0 || opts.help { fmt.Fprintf(os.Stderr, "Usage: %s [OPTION]...\n", os.Args[0]) flag.PrintDefaults() os.Exit(0) } if opts.version { fmt.Fprintln(os.Stderr, version.Version) os.Exit(0) } flagutil.SetFlagsFromEnv(flag.CommandLine, "FLANNELD") sm, err := newSubnetManager() if err != nil { log.Error("Failed to create SubnetManager: ", err) os.Exit(1) } // Register for SIGINT and SIGTERM log.Info("Installing signal handlers") sigs := make(chan os.Signal, 1) signal.Notify(sigs, os.Interrupt, syscall.SIGTERM) ctx, cancel := context.WithCancel(context.Background()) var runFunc func(ctx context.Context) if opts.listen != "" { if opts.remote != "" { log.Error("--listen and --remote are mutually exclusive") os.Exit(1) } log.Info("running as server") runFunc = func(ctx context.Context) { remote.RunServer(ctx, sm, opts.listen, opts.remoteCAFile, opts.remoteCertfile, opts.remoteKeyfile) } } else { nm, err := network.NewNetworkManager(ctx, sm) if err != nil { log.Error("Failed to create NetworkManager: ", err) os.Exit(1) } runFunc = func(ctx context.Context) { nm.Run(ctx) } } wg := sync.WaitGroup{} wg.Add(1) go func() { runFunc(ctx) wg.Done() }() <-sigs // unregister to get default OS nuke behaviour in case we don't exit cleanly signal.Stop(sigs) log.Info("Exiting...") cancel() wg.Wait() }
func main() { // Parse the command line flags. if err := flag.CommandLine.Parse(os.Args[1:]); err != nil { fmt.Fprintln(os.Stderr, err.Error()) os.Exit(1) } if err := flagutil.SetFlagsFromEnv(flag.CommandLine, "REGISTRY_MONITOR"); err != nil { fmt.Fprintln(os.Stderr, err.Error()) os.Exit(1) } lvl, err := log.ParseLevel(*level) if err != nil { fmt.Fprintln(os.Stderr, err.Error()) os.Exit(1) } log.SetLevel(lvl) // Ensure we have proper values. if *dockerUsername == "" { log.Fatalln("Missing username flag") } if *dockerPassword == "" { log.Fatalln("Missing password flag") } if *registryHost == "" { log.Fatalln("Missing registry-host flag") } if *repository == "" { log.Fatalln("Missing repository flag") } if *baseLayer == "" { log.Fatalln("Missing base-layer-id flag") } // Register the metrics. for _, metric := range prometheusMetrics { err := prometheus.Register(metric) if err != nil { log.Fatalf("Failed to register metric: %v", err) } } // Setup the HTTP server. http.Handle("/metrics", prometheus.Handler()) http.HandleFunc("/health", healthHandler) http.HandleFunc("/status", statusHandler) log.Infoln("Listening on", *listen) // Run the monitor routine. runMonitor() // Listen and serve. log.Fatal(http.ListenAndServe(*listen, nil)) }
func LoadConfig() Config { flags := flag.NewFlagSet("user-auth", flag.ExitOnError) consumerKey := flags.String("consumer-key", "", "Twitter Consumer Key") consumerSecret := flags.String("consumer-secret", "", "Twitter Consumer Secret") accessToken := flags.String("access-token", "", "Twitter Access Token") accessSecret := flags.String("access-secret", "", "Twitter Access Secret") combinedFeed := flags.Bool("combined-feed", false, "Combine multiple tweets from the same user into a single RSS entry?") // default value 0 is important to identify later where the config came from maxTweets := flags.Int("max-tweets", 0, "Maximum tweets per feed") combinedFeedHours := flags.Int("combined-feed-hours", 0, "if combined-tweet, how many hours should be combined together?") debug := flags.Bool("debug", false, "Debug") configFile := flags.String("config", "", "Configiguration file") flagutil.SetFlagsFromEnv(flags, "TWITTER2RSS") flags.Parse(os.Args[1:]) var conf Config if len(*configFile) != 0 { fmt.Println("Loading configuration file.") conf = LoadConfigFile(*configFile) } if *consumerKey != "" { conf.ConsumerKey = *consumerKey } if *consumerSecret != "" { conf.ConsumerSecret = *consumerSecret } if *accessToken != "" { conf.AccessToken = *accessToken } if *accessSecret != "" { conf.AccessSecret = *accessSecret } // command line argument set if *debug == true { conf.Debug = *debug } // command line argument set if *combinedFeed == true { conf.CombinedFeed = *combinedFeed } // provided via command line if *maxTweets != 0 { conf.MaxTweets = *maxTweets } // not provided via config & command line if conf.MaxTweets == 0 { conf.MaxTweets = maxTweetsDefault } // provided via command line if *combinedFeedHours != 0 { conf.CombinedFeedHours = *combinedFeedHours } // not provided via config & command line if conf.CombinedFeedHours == 0 { conf.CombinedFeedHours = combinedFeedHoursDefault } if conf.CombinedFeedHours > 24 { fmt.Println("WARNING: please check your configuration. Combining feed by more as 24hours") fmt.Println(" doesn't make a difference and the result will be equal to 24") } if conf.ConsumerKey == "" || conf.ConsumerSecret == "" || conf.AccessToken == "" || conf.AccessSecret == "" { log.Fatal("Consumer key/secret and Access token/secret required") } return conf }
func main() { flags := struct { address string rpcAddress string dataPath string assetsPath string logLevel string certFile string keyFile string caFile string keyRingPath string version bool help bool }{} flag.StringVar(&flags.address, "address", "127.0.0.1:8080", "HTTP listen address") flag.StringVar(&flags.rpcAddress, "rpc-address", "", "RPC listen address") flag.StringVar(&flags.dataPath, "data-path", "/var/lib/bootcfg", "Path to data directory") flag.StringVar(&flags.assetsPath, "assets-path", "/var/lib/bootcfg/assets", "Path to static assets") // Log levels https://godoc.org/github.com/coreos/pkg/capnslog#LogLevel flag.StringVar(&flags.logLevel, "log-level", "info", "Set the logging level") // gRPC Server TLS flag.StringVar(&flags.certFile, "cert-file", "/etc/bootcfg/server.crt", "Path to the server TLS certificate file") flag.StringVar(&flags.keyFile, "key-file", "/etc/bootcfg/server.key", "Path to the server TLS key file") // TLS Client Authentication flag.StringVar(&flags.caFile, "ca-file", "/etc/bootcfg/ca.crt", "Path to the CA verify and authenticate client certificates") // Signing flag.StringVar(&flags.keyRingPath, "key-ring-path", "", "Path to a private keyring file") // subcommands flag.BoolVar(&flags.version, "version", false, "print version and exit") flag.BoolVar(&flags.help, "help", false, "print usage and exit") // parse command-line and environment variable arguments flag.Parse() if err := flagutil.SetFlagsFromEnv(flag.CommandLine, "BOOTCFG"); err != nil { log.Fatal(err.Error()) } // restrict OpenPGP passphrase to pass via environment variable only passphrase := os.Getenv("BOOTCFG_PASSPHRASE") if flags.version { fmt.Println(version.Version) return } if flags.help { flag.Usage() return } // validate arguments if url, err := url.Parse(flags.address); err != nil || url.String() == "" { log.Fatal("A valid HTTP listen address is required") } if finfo, err := os.Stat(flags.dataPath); err != nil || !finfo.IsDir() { log.Fatal("A valid -data-path is required") } if flags.assetsPath != "" { if finfo, err := os.Stat(flags.assetsPath); err != nil || !finfo.IsDir() { log.Fatalf("Provide a valid -assets-path or '' to disable asset serving: %s", flags.assetsPath) } } if flags.rpcAddress != "" { if _, err := os.Stat(flags.certFile); err != nil { log.Fatalf("Provide a valid TLS server certificate with -cert-file: %v", err) } if _, err := os.Stat(flags.keyFile); err != nil { log.Fatalf("Provide a valid TLS server key with -key-file: %v", err) } if _, err := os.Stat(flags.caFile); err != nil { log.Fatalf("Provide a valid TLS certificate authority for authorizing client certificates: %v", err) } } // logging setup lvl, err := capnslog.ParseLevel(strings.ToUpper(flags.logLevel)) if err != nil { log.Fatalf("invalid log-level: %v", err) } capnslog.SetGlobalLogLevel(lvl) capnslog.SetFormatter(capnslog.NewPrettyFormatter(os.Stdout, false)) // (optional) signing var signer, armoredSigner sign.Signer if flags.keyRingPath != "" { entity, err := sign.LoadGPGEntity(flags.keyRingPath, passphrase) if err != nil { log.Fatal(err) } signer = sign.NewGPGSigner(entity) armoredSigner = sign.NewArmoredGPGSigner(entity) } // storage store := storage.NewFileStore(&storage.Config{ Root: flags.dataPath, }) // core logic server := server.NewServer(&server.Config{ Store: store, }) // gRPC Server (feature disabled by default) if flags.rpcAddress != "" { log.Infof("starting bootcfg gRPC server on %s", flags.rpcAddress) log.Infof("Using TLS server certificate: %s", flags.certFile) log.Infof("Using TLS server key: %s", flags.keyFile) log.Infof("Using CA certificate: %s to authenticate client certificates", flags.caFile) lis, err := net.Listen("tcp", flags.rpcAddress) if err != nil { log.Fatalf("failed to start listening: %v", err) } tlsinfo := tlsutil.TLSInfo{ CertFile: flags.certFile, KeyFile: flags.keyFile, CAFile: flags.caFile, } tlscfg, err := tlsinfo.ServerConfig() if err != nil { log.Fatalf("Invalid TLS credentials: %v", err) } grpcServer := rpc.NewServer(server, tlscfg) go grpcServer.Serve(lis) defer grpcServer.Stop() } // HTTP Server config := &web.Config{ Store: store, AssetsPath: flags.assetsPath, Signer: signer, ArmoredSigner: armoredSigner, } httpServer := web.NewServer(config) log.Infof("starting bootcfg HTTP server on %s", flags.address) err = http.ListenAndServe(flags.address, httpServer.HTTPHandler()) if err != nil { log.Fatalf("failed to start listening: %v", err) } }
func main() { flags := struct { address string configPath string dataPath string assetsPath string logLevel string version bool help bool }{} flag.StringVar(&flags.address, "address", "127.0.0.1:8080", "HTTP listen address") flag.StringVar(&flags.configPath, "config", "./data/config.yaml", "Path to config file") flag.StringVar(&flags.dataPath, "data-path", "./data", "Path to data directory") flag.StringVar(&flags.assetsPath, "assets-path", "./assets", "Path to static assets") // available log levels https://godoc.org/github.com/coreos/pkg/capnslog#LogLevel flag.StringVar(&flags.logLevel, "log-level", "info", "Set the logging level") // subcommands flag.BoolVar(&flags.version, "version", false, "print version and exit") flag.BoolVar(&flags.help, "help", false, "print usage and exit") // parse command-line and environment variable arguments flag.Parse() if err := flagutil.SetFlagsFromEnv(flag.CommandLine, "BOOTCFG"); err != nil { log.Fatal(err.Error()) } if flags.version { fmt.Println(version) return } if flags.help { flag.Usage() return } // validate arguments if url, err := url.Parse(flags.address); err != nil || url.String() == "" { log.Fatal("A valid HTTP listen address is required") } if finfo, err := os.Stat(flags.configPath); err != nil || finfo.IsDir() { log.Fatal("A path to a config file is required") } if finfo, err := os.Stat(flags.dataPath); err != nil || !finfo.IsDir() { log.Fatal("A path to a data directory is required") } if finfo, err := os.Stat(flags.assetsPath); err != nil || !finfo.IsDir() { log.Fatal("A path to an assets directory is required") } // logging setup lvl, err := capnslog.ParseLevel(strings.ToUpper(flags.logLevel)) if err != nil { log.Fatalf("Invalid log-level: %v", err.Error()) } capnslog.SetGlobalLogLevel(lvl) capnslog.SetFormatter(capnslog.NewPrettyFormatter(os.Stdout, false)) // storage store := api.NewFileStore(http.Dir(flags.dataPath)) // load bootstrap config cfg, err := config.LoadConfig(flags.configPath) if err != nil { log.Fatal(err) } store.BootstrapGroups(cfg.Groups) // API server config := &api.Config{ Store: store, AssetsPath: flags.assetsPath, } server := api.NewServer(config) log.Infof("starting bootcfg API Server on %s", flags.address) err = http.ListenAndServe(flags.address, server.HTTPHandler()) if err != nil { log.Fatalf("failed to start listening: %s", err) } }
func main() { flags := flag.NewFlagSet("user-auth", flag.ExitOnError) consumerKey := flags.String("consumer-key", "", "Twitter Consumer Key") consumerSecret := flags.String("consumer-secret", "", "Twitter Consumer Secret") accessToken := flags.String("access-token", "", "Twitter Access Token") accessSecret := flags.String("access-secret", "", "Twitter Access Secret") flags.Parse(os.Args[1:]) flagutil.SetFlagsFromEnv(flags, "TWITTER") if *consumerKey == "" || *consumerSecret == "" || *accessToken == "" || *accessSecret == "" { log.Fatal("Consumer key/secret and Access token/secret required") } config := oauth1.NewConfig(*consumerKey, *consumerSecret) token := oauth1.NewToken(*accessToken, *accessSecret) // OAuth1 http.Client will automatically authorize Requests httpClient := config.Client(oauth1.NoContext, token) // Twitter Client client := twitter.NewClient(httpClient) // Convenience Demux demultiplexed stream messages demux := twitter.NewSwitchDemux() demux.Tweet = func(tweet *twitter.Tweet) { fmt.Println(tweet.Text) } demux.DM = func(dm *twitter.DirectMessage) { fmt.Println(dm.SenderID) } demux.Event = func(event *twitter.Event) { fmt.Printf("%#v\n", event) } fmt.Println("Starting Stream...") // FILTER filterParams := &twitter.StreamFilterParams{ Track: []string{"cat"}, StallWarnings: twitter.Bool(true), } stream, err := client.Streams.Filter(filterParams) if err != nil { log.Fatal(err) } // USER (quick test: auth'd user likes a tweet -> event) // userParams := &twitter.StreamUserParams{ // StallWarnings: twitter.Bool(true), // With: "followings", // Language: []string{"en"}, // } // stream, err := client.Streams.User(userParams) // if err != nil { // log.Fatal(err) // } // SAMPLE // sampleParams := &twitter.StreamSampleParams{ // StallWarnings: twitter.Bool(true), // } // stream, err := client.Streams.Sample(sampleParams) // if err != nil { // log.Fatal(err) // } // Receive messages until stopped or stream quits go demux.HandleChan(stream.Messages) // Wait for SIGINT and SIGTERM (HIT CTRL-C) ch := make(chan os.Signal) signal.Notify(ch, syscall.SIGINT, syscall.SIGTERM) log.Println(<-ch) fmt.Println("Stopping Stream...") stream.Stop() }