main.rs

mod client;
mod downloader;
mod player;
mod song;
mod util;
mod websocket_command;

use futures_signals::signal::Mutable;
use std::env;
use std::io::Error;
use std::net::TcpListener;
use std::net::TcpStream;
use std::sync::Arc;
use std::thread::spawn;
use tungstenite::accept;
use tungstenite::Message;

use song::Song;

fn main() {
    let playlist = Mutable::new(Vec::<Song>::new());

    println!("starting");

    let playlist_1 = Mutable::clone(&playlist);
    spawn(move || {
        let player_secret = Arc::new(
            env::var("SPOCCIFY_PLAYER_SECRET")
                .expect("No player secret provided!"),
        );
        let client_secret = Arc::new(
            env::var("SPOCCIFY_CLIENT_SECRET")
                .expect("No client secret provided!"),
        );

        let bind_host =
            env::var("SPOCCIFY_BIND_HOST").unwrap_or("localhost".to_owned());
        let bind_port =
            env::var("SPOCCIFY_BIND_PORT").unwrap_or("8080".to_owned());

        let bind_address = format!("{}:{}", bind_host, bind_port);

        println!("Listening for websocket connections on {}!", bind_address);

        let server = TcpListener::bind(bind_address).expect("Failed to bind websocket port!");
        for stream in server.incoming() {
            let playlist_clone = Mutable::clone(&playlist_1);
            let player_secret_clone = Arc::clone(&player_secret);
            let client_secret_clone = Arc::clone(&client_secret);
            spawn(move || {
                handle_websocket(
                    stream,
                    playlist_clone,
                    player_secret_clone,
                    client_secret_clone,
                )
            });
        }
    });

    let playlist_2 = Mutable::clone(&playlist);
    spawn(move || {
        println!("Watching for downloadable songs!");

        downloader::manage_downloads(playlist_2);
    });

    loop {}
}

fn handle_websocket(
    stream: Result<TcpStream, Error>,
    playlist: Mutable<Vec<Song>>,
    player_secret: Arc<String>,
    client_secret: Arc<String>,
) -> () {
    if let Err(_) = stream {
        eprintln!("Failed to accept TCP stream!");
        return;
    }
    let stream = stream.unwrap();
    let websocket = accept(stream);
    if let Err(_) = websocket {
        eprintln!("Failed to open websocket!");
        return;
    }
    let mut websocket = websocket.unwrap();

    let msg = websocket.read_message();
    if let Err(_) = msg {
        eprintln!("Error receiving websocket message!");
        return;
    }
    let msg = msg.unwrap();

    if let Message::Text(text) = msg {
        if text == *player_secret {
            player::handle_player(&mut websocket, &playlist);
        } else if text == *client_secret {
            client::handle_client(&mut websocket, &playlist);
        } else {
            eprintln!("Invalid authentication token!");
            return;
        }

        /* match text {
            *player_secret => player::handle_player(&mut websocket, &playlist),
            *client_secret => client::handle_client(&mut websocket, &playlist),
            _ => {
                eprintln!("Invalid authentication token!");
                return;
            }
        } */
    } else {
        eprintln!("New websocket connection did not immediately send authentication token!");
        return;
    }
}