Example #1
0
func RunPostSongsBench(c crowdsound.CrowdSoundClient, amount, songsToPost int) (metrics.Histogram, error) {
	h := metrics.NewHistogram(metrics.NewUniformSample(amount))

	userID := randomString(32)
	for i := 0; i < amount; i++ {
		start := time.Now()

		stream, err := c.PostSong(context.Background())
		if err != nil {
			return h, err
		}

		for song := range songGenerator(songsToPost, 0.1) {
			song.UserId = userID
			if err = stream.Send(song); err != nil {
				return h, err
			}
		}

		stream.CloseAndRecv()

		h.Update(time.Since(start).Nanoseconds())
	}

	return h, nil
}
Example #2
0
func printQueue(client crowdsound.CrowdSoundClient) {
	stream, err := client.GetQueue(context.Background(), &crowdsound.GetQueueRequest{
		UserId: *userID,
	})
	if err != nil {
		log.Fatalf("Error calling GetQueue(): %v", err)
	}

	var count int

	for {
		song, err := stream.Recv()
		if err == io.EOF {
			break
		}
		if err != nil {
			log.Fatalf("Error retrieving song: %v", err)
		}

		if song.IsBuffered {
			if song.IsPlaying {
				log.Printf("Song: [%v] %v - %v (buffered) (playing)", song.Genre, song.Artist, song.Name)
			} else {
				log.Printf("Song: [%v] %v - %v (buffered)", song.Genre, song.Artist, song.Name)
			}
		} else {
			log.Printf("Song: [%v] %v - %v", song.Genre, song.Artist, song.Name)
		}
		count++
	}

	log.Println("Queue size:", count)
}
Example #3
0
func printPlaying(client crowdsound.CrowdSoundClient) {
	resp, err := client.GetPlaying(context.Background(), &crowdsound.GetPlayingRequest{})
	if err != nil {
		log.Fatalf("Error calling GetPlaying(): %v", err)
	}

	log.Println("Playing:", resp)
}
Example #4
0
func printMeta(client crowdsound.CrowdSoundClient) {
	resp, err := client.GetSessionData(context.Background(), &crowdsound.GetSessionDataRequest{})
	if err != nil {
		log.Fatalf("Error calling GetSessionData(): %v", err)
	}

	log.Println("Session Data:", resp)
}
Example #5
0
func voteSkip(client crowdsound.CrowdSoundClient) {
	_, err := client.VoteSkip(context.Background(), &crowdsound.VoteSkipRequest{
		UserId: *userID,
	})
	if err != nil {
		log.Fatalf("Error calling VoteSkip(): %v", err)
	}

	log.Println("Voted for skip")
}
Example #6
0
func vote(client crowdsound.CrowdSoundClient) {
	_, err := client.VoteSong(context.Background(), &crowdsound.VoteSongRequest{
		UserId: *userID,
		Name:   songs[4].Name,
		Artist: songs[4].Artist[0],
		Like:   true,
	})
	if err != nil {
		log.Fatalf("Error calling VoteSong(): %v", err)
	}
}
Example #7
0
func RunGetSessionDataBench(c crowdsound.CrowdSoundClient, amount int) (metrics.Histogram, error) {
	h := metrics.NewHistogram(metrics.NewUniformSample(amount))
	for i := 0; i < amount; i++ {
		start := time.Now()
		if _, err := c.GetSessionData(context.Background(), &crowdsound.GetSessionDataRequest{}); err != nil {
			return h, err
		}

		h.Update(time.Since(start).Nanoseconds())
	}

	return h, nil
}
Example #8
0
func postSongs(client crowdsound.CrowdSoundClient) {
	stream, err := client.PostSong(context.Background())
	if err != nil {
		log.Fatalf("Error calling PostSong(): %v", err)
	}
	defer stream.CloseAndRecv()

	for _, song := range songs {
		log.Println("Posting song:", song)
		song.UserId = *userID
		err := stream.Send(song)
		if err != nil {
			log.Fatalf("Error sending song: %v", err)
		}
	}
}
Example #9
0
func RunGetQueueBench(c crowdsound.CrowdSoundClient, amount int) (metrics.Histogram, error) {
	h := metrics.NewHistogram(metrics.NewUniformSample(amount))

	// To make the queue meaningful, we want there to actually
	// be a queue. Idealy, we could try various queue sizes, but
	// time is of the essence!
	postStream, err := c.PostSong(context.Background())
	if err != nil {
		return h, err
	}

	for song := range songGenerator(10, 0) {
		song.UserId = randomString(32)
		if err = postStream.Send(song); err != nil {
			return h, err
		}
	}

	if _, err = postStream.CloseAndRecv(); err != nil {
		return h, err
	}

	for i := 0; i < amount; i++ {
		start := time.Now()
		queueStream, err := c.GetQueue(context.Background(), &crowdsound.GetQueueRequest{})
		if err != nil {
			return h, err
		}

		for {
			_, err := queueStream.Recv()
			if err == io.EOF {
				break
			}
			if err != nil {
				log.Fatal(err)
			}
		}

		h.Update(time.Since(start).Nanoseconds())
	}

	return h, nil
}
Example #10
0
func RunListTrendingArtists(c crowdsound.CrowdSoundClient, amount int) (metrics.Histogram, error) {
	h := metrics.NewHistogram(metrics.NewUniformSample(amount))

	// To make trending artists meaningful, add a bunch of artists.
	postStream, err := c.PostSong(context.Background())
	if err != nil {
		return h, err
	}

	for song := range songGenerator(100, 1.0) {
		song.UserId = randomString(32)
		if err = postStream.Send(song); err != nil {
			return h, err
		}
	}

	if _, err = postStream.CloseAndRecv(); err != nil {
		return h, err
	}

	for i := 0; i < amount; i++ {
		start := time.Now()
		listStream, err := c.ListTrendingArtists(context.Background(), &crowdsound.ListTrendingArtistsRequest{})
		if err != nil {
			return h, err
		}

		for {
			_, err := listStream.Recv()
			if err == io.EOF {
				break
			}
			if err != nil {
				log.Fatal(err)
			}
		}

		h.Update(time.Since(start).Nanoseconds())
	}

	return h, nil
}
Example #11
0
func RunVoteSongsBench(c crowdsound.CrowdSoundClient, amount int) (metrics.Histogram, error) {
	h := metrics.NewHistogram(metrics.NewUniformSample(amount))

	// Generate songs to vote on
	postStream, err := c.PostSong(context.Background())
	if err != nil {
		return h, err
	}

	var songToVote *crowdsound.PostSongRequest
	for song := range songGenerator(1, 0) {
		song.UserId = randomString(32)
		if err = postStream.Send(song); err != nil {
			return h, err
		}
		songToVote = song
	}

	if _, err = postStream.CloseAndRecv(); err != nil {
		return h, err
	}

	userID := randomString(32)
	for i := 0; i < amount; i++ {
		start := time.Now()
		_, err := c.VoteSong(context.Background(), &crowdsound.VoteSongRequest{
			UserId: userID,
			Name:   songToVote.Name,
			Artist: songToVote.Artist[0],
			Like:   true,
		})
		if err != nil {
			return h, err
		}

		h.Update(time.Since(start).Nanoseconds())
	}

	return h, nil
}
Example #12
0
func ping(client crowdsound.CrowdSoundClient) {
	_, err := client.Ping(context.Background(), &crowdsound.PingRequest{UserId: *userID})
	if err != nil {
		log.Fatalf("Error calling Ping(): %v", err)
	}
}