#[derive(Serialize,Debug)]
struct LoadingRenderContext<'r> {
- token : &'r str,
+ ptoken : &'r str,
}
-
-#[get("/<token>")]
-fn loading(token : InstanceAccess<PlayerId>) -> Result<Template,RE> {
- let c = LoadingRenderContext { token : token.raw_token };
+#[get("/<ptoken>")]
+fn loading(ptoken : InstanceAccess<PlayerId>) -> Result<Template,RE> {
+ let c = LoadingRenderContext { ptoken : ptoken.raw_token };
Ok(Template::render("loading",&c))
}
#[derive(Serialize,Debug)]
struct SessionRenderContext {
- clientid : ClientId,
+ ctoken : String,
player : PlayerId,
defs : Vec<String>,
uses : Vec<String>,
#[derive(Deserialize)]
struct SessionForm {
- token : String,
+ ptoken : String,
}
#[post("/_/session", format="json", data="<form>")]
fn session(form : Json<SessionForm>) -> Result<Template,RE> {
// make session in this game, log a message to other players
- let iad = lookup_token(&form.token).ok_or_else(|| anyhow!("unknown token"))?;
+ let iad = lookup_token(&form.ptoken)
+ .ok_or_else(|| anyhow!("unknown token"))?;
let player = iad.ident;
let c = {
let mut ig = iad.g.lock().map_err(|e| anyhow!("lock poison {:?}",&e))?;
- let pl = ig.gs.players.get_mut(player)
+ let _pl = ig.gs.players.get_mut(player)
.ok_or_else(|| anyhow!("player deleted"))?;
- let client = Client { player };
- let clientid = ig.clients.insert(client);
+ let cl = Client { player };
+ let client = ig.clients.insert(cl);
+
+ let ciad = InstanceAccessDetails {
+ g : iad.g.clone(),
+ ident : client,
+ };
+ let ctoken = record_token(ciad);
let mut uses = vec![];
let mut defs = vec![];
}
SessionRenderContext {
- clientid,
+ ctoken : ctoken.0,
player,
defs,
uses,
let u_gen =
if client == p.lastclient { p.gen_lastclient }
else { p.gen_before_lastclient };
- if u_gen > form.g { Err(OpError::Conflict)? }
+ if u_gen > q_gen { Err(OpError::Conflict)? }
if p.held != None { Err(OpError::PieceHeld)? };
p.held = Some(player);
gs.gen += 1;
}
*/
-#[get("/_/updates/<token>")]
+#[get("/_/updates/<ctoken>")]
#[throws(RE)]
-fn updates(token : InstanceAccess<ClientId>)
+fn updates(ctoken : InstanceAccess<ClientId>)
-> impl response::Responder<'static> {
- let iad = token.i;
+ let iad = ctoken.i;
let client = iad.ident;
let _ = {
let mut ig = iad.g.lock().map_err(|e| anyhow!("lock poison {:?}",&e))?;
- let g = &mut ig.gs;
+ let _g = &mut ig.gs;
let cl = ig.clients.get(client).ok_or_else(|| anyhow!("no client"))?;
- let player = cl.player;
+ let _player = cl.player;
};
let tc = TestCounterInner { next : 0 };
let tc = BufReader::new(tc);
visible_slotmap_key!{ PlayerId('#') }
#[derive(Clone,Debug,Eq,PartialEq,Ord,PartialOrd,Hash)]
-pub struct RawToken (String);
+pub struct RawToken (pub String);
impl Borrow<str> for RawToken {
fn borrow(&self) -> &str { &self.0 }
}
Id::global_tokens().read().unwrap().get(s).cloned()
}
+pub fn record_token<Id : AccessId>(iad : InstanceAccessDetails<Id>)
+ -> RawToken {
+ let mut rng = thread_rng();
+ let token = RawToken (
+ repeat_with(|| rng.sample(Alphanumeric))
+ .take(64).collect()
+ );
+ Id::global_tokens().write().unwrap().insert(token.clone(), iad);
+ token
+}
+
const XXX_PLAYERS_TOKENS : &[(&str, &str)] = &[
("kmqAKPwK4TfReFjMor8MJhdRPBcwIBpe", "alice"),
("ccg9kzoTh758QrVE1xMY7BQWB36dNJTx", "bob"),
pub use std::borrow::Borrow;
pub use std::convert::TryFrom;
pub use std::str::FromStr;
+pub use std::iter::repeat_with;
pub use thiserror::Error;
pub use anyhow::{Context,anyhow};
pub use rocket::response::NamedFile;
pub use rocket::response;
+pub use rand::thread_rng;
+pub use rand::Rng;
+pub use rand::distributions::Alphanumeric;
+
pub use slotmap::dense::DenseSlotMap;
pub type SecondarySlotMap<K,V> = slotmap::secondary::SecondaryMap<K,V>;
pub use index_vec::{define_index_type,index_vec,IndexVec};
<body id="loading_body">
-<h1 id="loading_token" data-token="{{ token }}">Loading!</h1>
+<h1 id="loading_token" data-ptoken="{{ ptoken }}">Loading!</h1>
<div id="error"></div>
<script src="/_/script.js"></script>
dragging = DRAGGING.MAYBE_GRAB;
set_grab(delt, us);
api('grab', {
- t : token,
+ t : ctoken,
g : gen,
p : delt.dataset.p,
- c : clientid,
s : 0,
})
}
function startup() {
var body = document.getElementById("main-body");
- clientid = body.dataset.clientid;
+ ctoken = body.dataset.ctoken;
us = body.dataset.us;
status_node = document.getElementById('status');
status_node.innerHTML = 'js-done'
space = document.getElementById('space');
svg_ns = space.getAttribute('xmlns');
- es = new EventSource("/_/updates/"+token+"/"+clientid);
+ es = new EventSource("/_/updates/"+ctoken);
es.onmessage = function(event) {
var j = JSON.parse(event.data);
var k = Object.keys(j)[0];
function doload(){
console.log('DOLOAD');
var elem = document.getElementById('loading_token');
- token = elem.dataset.token;
+ ptoken = elem.dataset.ptoken;
xhr_post_then('/_/session',
- JSON.stringify({ token : token }),
+ JSON.stringify({ ptoken : ptoken }),
loaded);
}
-<body id="main-body" data-clientid="{{clientid}}" data-us="{{player}}">
+<body id="main-body" data-ctoken="{{ctoken}}" data-us="{{player}}">
<h1>Hi!</h1>
<div id="error"></div>
<p>