From 91a1321f0ae1a02df9c3d1a8f890d84a94953a61 Mon Sep 17 00:00:00 2001
From: natrixaeria <janng@gmx.de>
Date: Sun, 19 May 2019 17:09:56 +0200
Subject: Validate tokens and then push client

---
 game_server/src/backend_connection.rs | 57 +++++++++++++++++++++++++++++------
 1 file changed, 47 insertions(+), 10 deletions(-)

(limited to 'game_server/src/backend_connection.rs')

diff --git a/game_server/src/backend_connection.rs b/game_server/src/backend_connection.rs
index 9307c4a..6d3537a 100644
--- a/game_server/src/backend_connection.rs
+++ b/game_server/src/backend_connection.rs
@@ -1,31 +1,68 @@
 use reqwest::{Response, Client, Url, UrlError, Error as ReqError};
+use std::sync::mpsc::{Sender, Receiver};
+use std::sync::mpsc;
+use super::gameserver::Token;
 
 pub struct BackendConnection {
     host: String,
-    client: Client,
-    last_response: Option<Result<Response, ReqError>>
+    req_sender: Sender<RequestData>,
+    res_rec: Receiver<ResponseResult>,
 }
 
+#[derive(Debug)]
+pub enum BackendError {
+    UrlError(UrlError),
+    RequestError(ReqError),
+    InvalidTokenFormat,
+    InvalidToken,
+}
+
+pub type TokenValidity = Result<(), BackendError>;
+pub type RequestData = Url;
+pub type ResponseResult = Result<Response, ReqError>;
+
 impl BackendConnection {
+    fn run_background(req_rec: Receiver<RequestData>, res_sender: Sender<ResponseResult>) {
+        let client = Client::new();
+        loop {
+            let request_data = req_rec.recv().unwrap();
+            let location = request_data;
+            let request = client.get(location);
+            let response = request.send();
+            res_sender.send(response);
+        }
+    }
+
     pub fn new(host: &str) -> Self {
+        let (req_sender, req_rec): (Sender<RequestData>, Receiver<RequestData>)
+                                    = mpsc::channel();
+        let (res_sender, res_rec): (Sender<ResponseResult>, Receiver<ResponseResult>)
+                                    = mpsc::channel();
+        std::thread::spawn(move || Self::run_background(req_rec, res_sender));
         BackendConnection {
             host: host.to_string(),
-            client: Client::new(),
-            last_response: None
+            req_sender,
+            res_rec,
         }
     }
 
-    pub fn request(&mut self, location: &str) -> Result<(), UrlError> {
-        Ok(self.last_response =
-                Some(self.client.get(Url::parse(&format!("{}{}", self.host, location))?)
-                           .send()))
+    pub fn request(&self, location: &str) -> Result<(), UrlError> {
+        Ok(self.req_sender.send(Url::parse(&format!("{}{}", self.host, location))?).unwrap())
     }
 
-    pub fn get_response(&self) -> &Option<Result<Response, ReqError>> {
-        &self.last_response
+    pub fn get_response(&self) -> ResponseResult {
+        self.res_rec.recv().unwrap()
     }
     
     pub fn host_name<'a>(&'a self) -> &'a str {
         &self.host
     }
+
+    pub fn validate_token(&self, token: &Token) -> TokenValidity {
+        let location = format!("/api/lobby/tokens/{}", token);
+        self.request(&location).map_err(|err| BackendError::UrlError(err))?;
+        let response = self.get_response();
+        println!("backend response: {:?}", response);
+        Ok(())
+    }
 }
-- 
cgit v1.2.3-70-g09d2