Exemplo n.º 1
0
Arquivo: config.go Projeto: andynu/rfk
func Load(configPath string, dataPath string) {
	ConfigPath = DefaultConfigPath(configPath)
	DataPath = DefaultDataPath(dataPath)

	CreateDefaultConfig(ConfigPath)
	CreateDataPath(DataPath)

	fmt.Println("Config: %q", ConfigPath)
	config, err := loadJsonConfig(ConfigPath)
	if err != nil {
		panic(err)
	}

	Config.WeatherUndergroundKey = config["weather_underground_key"]
	Config.WeatherUndergroundLocation = config["weather_underground_location"]

	observer.Notify("config.loaded", struct{}{})
}
Exemplo n.º 2
0
Arquivo: player.go Projeto: andynu/rfk
func Play(song library.Song) error {
	LastSong = CurrentSong
	CurrentSong = &song
	log.Printf("player: playing %q (%f)", song.Path, song.Rank)
	logMetadata(song.Path)

	if sleepPlayer {
		playerCmd = exec.Command("sleep", "5")
	} else {
		playerCmd = exec.Command(playerBin, song.Path)
	}
	err := playerCmd.Run()
	if err != nil {
		return fmt.Errorf("player: %v", err)
	}
	observer.Notify("player.played", &song)
	return nil
}
Exemplo n.º 3
0
// loads Songs from either song_hashes.txt or songs.txt (first to exist).
// loads the path graph
func Load() {

	songHashMap = make(map[string][]*Song, 1000)
	songPathMap = make(map[string]*Song, 1000)

	songHashesPath := path.Join(config.DataPath, "song_hashes.txt")
	//songsPath := path.Join(config.DataPath, "songs.txt")
	songErrorsPath := path.Join(config.DataPath, "song_errors.txt")

	loadSongErrors(songErrorsPath)
	//loadSongs(songsPath)
	loadSongHashesMap(songHashesPath)
	go IdentifySongs(Songs, songHashesPath)

	observer.Notify("library.loaded", struct{}{})
	log.Printf("Loaded %d songs", len(Songs))
	PathRoots = graph.LoadGraph(Songs)

}
Exemplo n.º 4
0
Arquivo: karma.go Projeto: andynu/rfk
// Build up the SongKarma map, and spread impressiosn to library.Song.Rank
func Load() error {
	SongKarma = make(map[string]int)

	impressionCount := 0

	timestampIdx := 0
	logTypeIdx := 1

	// logType = karma
	hashIdx := 2
	impressionIdx := 3

	// logType = env
	tagIdx := 2
	valIdx := 3

	impressionLogPath := path.Join(config.DataPath, "impression.log")
	log.Printf("Reading impressions from: %q", impressionLogPath)
	f, err := os.Open(impressionLogPath)
	if err != nil {
		return err
	}
	defer f.Close()

	r := csv.NewReader(f)
	r.Comma = '\t'
	r.Comment = '#'

	records, err := r.ReadAll()
	if err != nil {
		return err
	}

	for _, record := range records {
		if len(record) != 4 {
			return fmt.Errorf("Malformed impression.log, wrong number of columns %d expected 4", len(record))
		}
		timestampStr := record[timestampIdx]
		timestamp, _ := time.Parse("2016/02/21 20:18:49.091737", timestampStr)
		logType := record[logTypeIdx]
		switch logType {
		case "karma":
			hash := record[hashIdx]
			impression, _ := strconv.Atoi(record[impressionIdx])
			SongKarma[hash] += impression

			song, err := library.ByHash(hash)

			if err != nil {
				continue
			}

			impressionCount++
			historicalEnv.Impress(timestamp, song, impression)
			go song.PathGraphImpress(impression)

		case "env":
			sensor := record[tagIdx]
			val := record[valIdx]
			historicalEnv.Update(timestamp, sensor, val)
		}
	}
	//historicalEnv.Print()
	//log.Printf("%v", SongKarma)

	sort.Sort(library.Songs)

	observer.Notify("karma.loaded", struct{}{})
	log.Printf("Loading karma: %d impressions loaded", impressionCount)
	return nil
}
Exemplo n.º 5
0
Arquivo: player.go Projeto: andynu/rfk
func Skip() error {
	observer.Notify("player.skip", CurrentSong)
	return Stop()
}