コード例 #1
0
ファイル: twitter.go プロジェクト: voxelbrain/pixelpixel
// Hashtags returns a channel over which tweets can be received, which match
// at least one of the given hashtags.
func Hashtags(cred *Credentials, Hashtags ...string) (<-chan *Tweet, error) {
	c := make(chan *Tweet)
	restclient := twittergo.NewClient(&oauth1a.ClientConfig{
		ConsumerKey:    cred.ConsumerKey,
		ConsumerSecret: cred.ConsumerSecret,
	}, &oauth1a.UserConfig{
		AccessTokenKey:    cred.AccessToken,
		AccessTokenSecret: cred.AccessSecret,
	})

	httpstream.OauthCon = &oauth.OAuthConsumer{
		ConsumerKey:    cred.ConsumerKey,
		ConsumerSecret: cred.ConsumerSecret,
	}
	streamclient := httpstream.NewOAuthClient(&oauth.AccessToken{
		Token:  cred.AccessToken,
		Secret: cred.AccessSecret,
	}, newChannelConverter(c, restclient))

	err := streamclient.Filter(nil, Hashtags, nil, nil, false, nil)
	if err != nil {
		close(c)
	}
	return c, err
}
コード例 #2
0
ファイル: stream.go プロジェクト: JamesMcMinn/twitter
// Fills a channel with data from the Twitter gardenhose.
func FillStream(channel chan Tweet, consumerKey, consumerSecret, ot, osec string) {
	httpstream.OauthCon = oauth.NewConsumer(
		consumerKey,
		consumerSecret,
		oauth.ServiceProvider{
			RequestTokenUrl:   "http://api.twitter.com/oauth/request_token",
			AuthorizeTokenUrl: "https://api.twitter.com/oauth/authorize",
			AccessTokenUrl:    "https://api.twitter.com/oauth/access_token",
		})

	at := oauth.AccessToken{
		Token:  ot,
		Secret: osec,
	}

	client := httpstream.NewOAuthClient(&at, httpstream.OnlyTweetsFilter(func(line []byte) {
		channel <- JSONtoTweet(line)
	}))

	err := client.Sample(nil)
	if err != nil {
		httpstream.Log(httpstream.ERROR, err.Error())
	}
}
コード例 #3
0
ファイル: capturador.go プロジェクト: galaek/trendings
func main() {

	flag.Parse()
	httpstream.SetLogger(log.New(os.Stdout, "", log.Ldate|log.Ltime|log.Lshortfile), *logLevel)

	// Connectin to the local mongo database
	session, err := mgo.Dial("localhost")
	if err != nil {
		panic(err)
	}
	// We defer the session closing so we don't forget later
	defer session.Close()
	t := time.Now()
	collectionName := fmt.Sprintf("%d-%d-%d_%d:%d_%s", t.Year(), int(t.Month()), t.Day(), t.Hour(), t.Minute(), *collection)
	fmt.Println("Collection:", collectionName)
	// Creating DB "twitter" and Collection "tweets"
	c := session.DB("mundial").C(collectionName)
	// Optional. Switch the session to a monotonic behavior. session.SetMode(mgo.Monotonic, true)

	// make a go channel for sending from listener to processor
	// we buffer it, to help ensure we aren't backing up twitter or else they cut us off
	stream := make(chan []byte, 1000)
	done := make(chan bool)

	httpstream.OauthCon = oauth.NewConsumer(
		*consumerKey,
		*consumerSecret,
		oauth.ServiceProvider{
			RequestTokenUrl:   "http://api.twitter.com/oauth/request_token",
			AuthorizeTokenUrl: "https://api.twitter.com/oauth/authorize",
			AccessTokenUrl:    "https://api.twitter.com/oauth/access_token",
		})

	at := oauth.AccessToken{
		Token:  *ot,
		Secret: *osec,
	}

	// Creamos el cliente OAuth
	client := httpstream.NewOAuthClient(&at, httpstream.OnlyTweetsFilter(func(line []byte) { stream <- line }))
	fmt.Println("Cliente OAuth creado")
	// find list of userids we are going to search for
	userIds := make([]int64, 0)
	for _, userId := range strings.Split(*users, ",") {
		if id, err := strconv.ParseInt(userId, 10, 64); err == nil {
			userIds = append(userIds, id)
		}
	}
	var keywords []string
	if search != nil && len(*search) > 0 {
		keywords = strings.Split(*search, ",")
	}
	//err := client.Filter(userIds, keywords, []string{"es"}, nil, false, done)
	//var locats []string
	// locats := make([]string, 4)
	// locats[0] = "-180"
	// locats[1] = "-90"
	// locats[2] = "180"
	// locats[3] = "90"
	//err = client.Filter(userIds, keywords, nil, locats, false, done)
	err = client.Filter(userIds, keywords, nil, nil, false, done)
	//err := client.Filter(nil, keywords, nil, nil, false, done)
	if err != nil {
		httpstream.Log(httpstream.ERROR, err.Error())
	} else {
		fmt.Println("Filter realizado, esperando datos")
		go func() {
			// while this could be in a different "thread(s)"
			ct := 0
			//var tweet twittertypes.Tweet
			for tw := range stream {
				//println("Tweet", ct, "capturado")
				tweet := new(twittertypes.Tweet)
				json.Unmarshal(tw, &tweet)
				tweetstamp, err := time.Parse(time.RubyDate, tweet.Created_at)
				tweet.Epoch = tweetstamp.Unix()
				err = c.Insert(tweet)
				if err != nil {
					panic(err)
				}
				// heavy lifting
				ct++
				if ct >= *maxCt {
					done <- true
				}
			}
		}()
		_ = <-done
	}
}
コード例 #4
0
ファイル: twoauth.go プロジェクト: samuelkadolph/httpstream
func main() {

	flag.Parse()
	httpstream.SetLogger(log.New(os.Stdout, "", log.Ldate|log.Ltime|log.Lshortfile), *logLevel)

	// make a go channel for sending from listener to processor
	// we buffer it, to help ensure we aren't backing up twitter or else they cut us off
	stream := make(chan []byte, 1000)
	done := make(chan bool)

	httpstream.OauthCon = &oauth.OAuthConsumer{
		Service:          "twitter",
		RequestTokenURL:  "http://twitter.com/oauth/request_token",
		AccessTokenURL:   "http://twitter.com/oauth/access_token",
		AuthorizationURL: "http://twitter.com/oauth/authorize",
		ConsumerKey:      *ck,
		ConsumerSecret:   *cs,
		CallBackURL:      "oob",
		UserAgent:        "go/httpstream",
	}

	//at := goauthcon.GetAccessToken(rt.Token, pin)
	at := oauth.AccessToken{Id: "",
		Token:    *ot,
		Secret:   *osec,
		UserRef:  *user,
		Verifier: "",
		Service:  "twitter",
	}
	// the stream listener effectively operates in one "thread"/goroutine
	// as the httpstream Client processes inside a go routine it opens
	// That includes the handler func we pass in here
	client := httpstream.NewOAuthClient(&at, httpstream.OnlyTweetsFilter(func(line []byte) {
		stream <- line
		// although you can do heavy lifting here, it means you are doing all
		// your work in the same thread as the http streaming/listener
		// by using a go channel, you can send the work to a
		// different thread/goroutine
	}))

	keywords := strings.Split("android,golang,zeromq,javascript", ",")
	err := client.Filter([]int64{14230524, 783214}, keywords, false, done)
	if err != nil {
		httpstream.Log(httpstream.ERROR, err.Error())
	} else {

		go func() {
			// while this could be in a different "thread(s)"
			ct := 0
			for tw := range stream {
				println(string(tw))
				// heavy lifting
				ct++
				if ct > 10 {
					done <- true
				}
			}
		}()
		_ = <-done
	}

}
コード例 #5
0
ファイル: main.go プロジェクト: mihaip/streamspigot
func main() {
	flag.Parse()

	if len(*oauthConsumerKey) == 0 || len(*oauthConsumerSecret) == 0 || len(*oauthToken) == 0 || len(*oauthTokenSecret) == 0 || len(*streamSpigotHostname) == 0 || len(*streamSpigotSecret) == 0 {
		flag.Usage()
		return
	}

	baseUrl := fmt.Sprintf("http://%s/bird-feeder/pinger/", *streamSpigotHostname)
	followingUrl := fmt.Sprintf("%sfollowing?secret=%s", baseUrl, url.QueryEscape(*streamSpigotSecret))
	pingUrl := baseUrl + "ping"

	var followingUserIds []int64
	var followingUserIdMap map[int64]bool

	stream := make(chan []byte)
	done := make(chan bool)
	updateFollowingListTick := time.Tick(followingListUpdateIntervalNanosec)

	httpstream.OauthCon = &oauth.OAuthConsumer{
		Service:          "twitter",
		RequestTokenURL:  "http://twitter.com/oauth/request_token",
		AccessTokenURL:   "http://twitter.com/oauth/access_token",
		AuthorizationURL: "http://twitter.com/oauth/authorize",
		ConsumerKey:      *oauthConsumerKey,
		ConsumerSecret:   *oauthConsumerSecret,
		CallBackURL:      "oob",
		UserAgent:        "go/httpstream",
	}

	accessToken := oauth.AccessToken{
		Id:       "",
		Token:    *oauthToken,
		Secret:   *oauthTokenSecret,
		Verifier: "",
		Service:  "twitter",
	}

	client := httpstream.NewOAuthClient(&accessToken, func(line []byte) {
		stream <- line
	})

	updateFollowingList := func() {
		followingUserIds, followingUserIdMap = getFollowingList(followingUrl)

		fmt.Printf("Tracking updates for %d users...\n", len(followingUserIds))

		client.Close()
		err := client.Filter(
			followingUserIds,
			nil,   // no topic filter
			nil,   // no language filter
			nil,   // no location filter
			false, // don't watch for stalls
			done)
		if err != nil {
			fmt.Println(err)
		}
	}

	updateFollowingList()

	for {
		select {
		case <-updateFollowingListTick:
			updateFollowingList()
		case <-done:
			fmt.Printf("Client says it's done")
		case line := <-stream:
			switch {
			case bytes.HasPrefix(line, []byte(`{"event":`)):
				var event httpstream.Event
				json.Unmarshal(line, &event)
			case bytes.HasPrefix(line, []byte(`{"friends":`)):
				var friends httpstream.FriendList
				json.Unmarshal(line, &friends)
			default:
				tweet := httpstream.Tweet{}
				json.Unmarshal(line, &tweet)
				if tweet.User != nil && tweet.User.Id != nil {
					fmt.Printf("%s: %s\n", tweet.User.ScreenName, tweet.Text)

					userId := int64(*tweet.User.Id)

					// We ignore tweets that come from users that we're not following (the
					// Streaming API will also notify when tweets of theirs are retweeted or
					// replied to).
					if _, inMap := followingUserIdMap[userId]; inMap {
						// Similarly, we ignore tweets that are in reply to users that aren't
						// being followed. This will have false negatives: if user A follows X
						// and user B follows X and Z, a reply by X to Z will cause both A and
						// B's streams to get pinged, even though A won't actually see that
						// status. However, that should be rare.
						if tweet.In_reply_to_user_id != nil {
							if in_reply_to_user_id := int64(*tweet.In_reply_to_user_id); in_reply_to_user_id != 0 {
								if _, inMap := followingUserIdMap[in_reply_to_user_id]; !inMap {
									continue
								}
							}
						}

						go pingUser(userId, int64(*tweet.Id), pingUrl)
					}
				} else {
					fmt.Printf("No tweet?")
				}
			}
		}
	}
}
コード例 #6
0
ファイル: twoauth.go プロジェクト: araddon/httpstream
func main() {

	flag.Parse()
	httpstream.SetLogger(log.New(os.Stdout, "", log.Ldate|log.Ltime|log.Lshortfile), *logLevel)

	// make a go channel for sending from listener to processor
	// we buffer it, to help ensure we aren't backing up twitter or else they cut us off
	stream := make(chan []byte, 1000)
	done := make(chan bool)

	httpstream.OauthCon = oauth.NewConsumer(
		*consumerKey,
		*consumerSecret,
		oauth.ServiceProvider{
			RequestTokenUrl:   "http://api.twitter.com/oauth/request_token",
			AuthorizeTokenUrl: "https://api.twitter.com/oauth/authorize",
			AccessTokenUrl:    "https://api.twitter.com/oauth/access_token",
		})

	at := oauth.AccessToken{
		Token:  *ot,
		Secret: *osec,
	}
	// the stream listener effectively operates in one "thread"/goroutine
	// as the httpstream Client processes inside a go routine it opens
	// That includes the handler func we pass in here
	client := httpstream.NewOAuthClient(&at, httpstream.OnlyTweetsFilter(func(line []byte) {
		stream <- line
		// although you can do heavy lifting here, it means you are doing all
		// your work in the same thread as the http streaming/listener
		// by using a go channel, you can send the work to a
		// different thread/goroutine
	}))

	// find list of userids we are going to search for
	userIds := make([]int64, 0)
	for _, userId := range strings.Split(*users, ",") {
		if id, err := strconv.ParseInt(userId, 10, 64); err == nil {
			userIds = append(userIds, id)
		}
	}
	var keywords []string
	if search != nil && len(*search) > 0 {
		keywords = strings.Split(*search, ",")
	}
	err := client.Filter(userIds, keywords, []string{"en"}, nil, false, done)
	if err != nil {
		httpstream.Log(httpstream.ERROR, err.Error())
	} else {

		go func() {
			// while this could be in a different "thread(s)"
			ct := 0
			for tw := range stream {
				println(string(tw))
				// heavy lifting
				ct++
				if ct > *maxCt {
					done <- true
				}
			}
		}()
		_ = <-done
	}

}
コード例 #7
0
ファイル: bullhorn.go プロジェクト: ZachOrr/bullhorn
func main() {
	conf, err := loadConfig("config.json")
	if err != nil {
		fmt.Println("Error loading config!")
		fmt.Println(err)
		return
	}
	configuration = conf

	p.RegisterKey(configuration.ProwlKey)

	two = twilio.NewClient(configuration.TwilioSID, configuration.TwilioAuthToken, nil)
	if two == nil {
		fmt.Println("Couldn't set up Twilio")
		return
	}

	amzses.Init(configuration.AWSAccessKey, configuration.AWSSecretKey)
	fmt.Println("Configured SES")

	db, err = database.Connect(configuration.MongoURL)
	if err != nil {
		fmt.Println("Couldn't connect to Mongo database")
		fmt.Println(err)
		return
	}
	fmt.Println("Connected to MongoDB")

	cheers := time.NewTicker(10 * time.Minute)
	scrapeInfo := time.NewTicker(2 * time.Minute)
	go func() {
		for {
			select {
			case <-cheers.C:
				events, err := db.GetEventsForCurrentWeek()
				if err != nil {
					sendProwl("Time Error", "Couldn't get current events when sending Cheers", err)
					break
				}
				for _, e := range events {
					sendCheersForEvent(e)
				}
			case <-scrapeInfo.C:
				events, err := db.GetEventsForCurrentWeek()
				if err != nil {
					sendProwl("Time Error", "Couldn't get current events when scraping event info", err)
					break
				}
				for _, e := range events {
					if !e.AlliancesSent {
						sendAlliancesForEvent(e)
					}
					sendAwardsForEvent(e)
				}
			}
		}
	}()

	stream := make(chan []byte, 1000)
	done := make(chan bool)

	httpstream.OauthCon = oauth.NewConsumer(
		configuration.ConsumerKey,
		configuration.ConsumerSecret,
		oauth.ServiceProvider{
			RequestTokenUrl:   "http://api.twitter.com/oauth/request_token",
			AuthorizeTokenUrl: "https://api.twitter.com/oauth/authorize",
			AccessTokenUrl:    "https://api.twitter.com/oauth/access_token",
		})

	at := oauth.AccessToken{
		Token:  configuration.OAuthToken,
		Secret: configuration.OAuthSecret,
	}
	client := httpstream.NewOAuthClient(&at, httpstream.OnlyTweetsFilter(func(line []byte) {
		stream <- line
	}))
	fmt.Println("Connected to Twitter!")

	err = client.User(done)
	if err != nil {
		sendProwl("Error Starting Megaphone", "Couldn't start stream!", err)
		return
	}

	sendProwl("Started!", "Megaphone is running", nil)

	go func() {
		for line := range stream {
			handleLine(line)
		}
	}()
	_ = <-done
}