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()
}
