ntr/mnml
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

instance list

Browse Source
This commit is contained in:
ntr
2019-06-01 17:43:00 +10:00
parent 47b216cb11
commit dd4431aaa3
14 changed files with 95 additions and 106 deletions
Download Patch File Download Diff File Expand all files Collapse all files
server/src/account.rs
+2 -2
View File
@@ -190,8 +190,8 @@ pub fn account_instances(tx: &mut Transaction, account: &Account) -> Result<Vec<
let query = "
SELECT data, id
FROM instances
WHERE open = true
OR id IN (
WHERE finished = false
AND id IN (
SELECT instance
FROM players
WHERE account = $1
server/src/game.rs
+2
View File
@@ -585,6 +585,8 @@ impl Game {
if player.warnings >= 3 {
player.forfeit();
info!("upkeep: {:} forfeited", player.name);
//todo
// self.resolved.push(forfeit)
// self.log.push(format!("{:} forfeited.", player.name));
}
}
server/src/instance.rs
+15 -9
View File
@@ -595,9 +595,9 @@ pub fn instance_delete(tx: &mut Transaction, id: Uuid) -> Result<(), Error> {
return Ok(());
}
pub fn instance_get_open(tx: &mut Transaction) -> Result<Instance, Error> {
pub fn instance_list(tx: &mut Transaction) -> Result<Vec<Instance>, Error> {
let query = "
SELECT *
SELECT data, id
FROM instances
WHERE open = true;
";
@@ -605,15 +605,21 @@ pub fn instance_get_open(tx: &mut Transaction) -> Result<Instance, Error> {
let result = tx
.query(query, &[])?;
let returned = match result.iter().next() {
Some(row) => row,
None => return Err(err_msg("instance not found")),
};
let mut list = vec![];
let instance_bytes: Vec<u8> = returned.get("data");
let instance = from_slice::<Instance>(&instance_bytes)?;
for row in result.into_iter() {
let bytes: Vec<u8> = row.get(0);
let id = row.get(1);
return Ok(instance);
match from_slice::<Instance>(&bytes) {
Ok(i) => list.push(i),
Err(_e) => {
instance_delete(tx, id)?;
}
};
}
return Ok(list);
}
pub fn instances_need_upkeep(tx: &mut Transaction) -> Result<Vec<Instance>, Error> {
server/src/main.rs
+1 -1
View File
@@ -49,7 +49,7 @@ fn setup_logger() -> Result<(), fern::InitError> {
})
.level_for("postgres", log::LevelFilter::Info)
.level_for("tungstenite", log::LevelFilter::Info)
.level(log::LevelFilter::Debug)
.level(log::LevelFilter::Info)
.chain(std::io::stdout())
.chain(fern::log_file("log/mnml.log")?)
.apply()?;
server/src/net.rs
+1 -1
View File
@@ -118,7 +118,7 @@ pub fn start() {
},
// connection is closed
Err(e) => {
info!("{:?}", e);
debug!("{:?}", e);
return;
}
};
server/src/rpc.rs
+24 -14
View File
@@ -18,7 +18,7 @@ use account::{Account, account_create, account_login, account_from_token, accoun
use skill::{Skill};
use spec::{Spec};
use player::{Score};
use instance::{Instance, instance_state, instance_new, instance_ready, instance_join};
use instance::{Instance, instance_state, instance_list, instance_new, instance_ready, instance_join};
use vbox::{vbox_accept, vbox_apply, vbox_discard, vbox_combine, vbox_reclaim, vbox_unequip};
use item::{Item, ItemInfoCtr, item_info};
@@ -78,18 +78,18 @@ impl Rpc {
"game_skill" => Rpc::game_skill(data, &mut tx, account.unwrap(), client),
"game_ready" => Rpc::game_ready(data, &mut tx, account.unwrap(), client),
"instance_list" => Rpc::instance_list(data, &mut tx, account.unwrap(), client),
"instance_join" => Rpc::instance_join(data, &mut tx, account.unwrap(), client),
"instance_ready" => Rpc::instance_ready(data, &mut tx, account.unwrap(), client),
"instance_new" => Rpc::instance_new(data, &mut tx, account.unwrap(), client),
"instance_state" => Rpc::instance_state(data, &mut tx, account.unwrap(), client),
"player_vbox_accept" => Rpc::player_vbox_accept(data, &mut tx, account.unwrap(), client),
"player_vbox_apply" => Rpc::player_vbox_apply(data, &mut tx, account.unwrap(), client),
"player_vbox_combine" => Rpc::player_vbox_combine(data, &mut tx, account.unwrap(), client),
"player_vbox_discard" => Rpc::player_vbox_discard(data, &mut tx, account.unwrap(), client),
"player_vbox_reclaim" => Rpc::player_vbox_reclaim(data, &mut tx, account.unwrap(), client),
"player_vbox_unequip" => Rpc::player_vbox_unequip(data, &mut tx, account.unwrap(), client),
"vbox_accept" => Rpc::vbox_accept(data, &mut tx, account.unwrap(), client),
"vbox_apply" => Rpc::vbox_apply(data, &mut tx, account.unwrap(), client),
"vbox_combine" => Rpc::vbox_combine(data, &mut tx, account.unwrap(), client),
"vbox_discard" => Rpc::vbox_discard(data, &mut tx, account.unwrap(), client),
"vbox_reclaim" => Rpc::vbox_reclaim(data, &mut tx, account.unwrap(), client),
"vbox_unequip" => Rpc::vbox_unequip(data, &mut tx, account.unwrap(), client),
_ => Err(format_err!("unknown method - {:?}", v.method)),
};
@@ -269,6 +269,16 @@ impl Rpc {
return Ok(response);
}
fn instance_list(_data: Vec<u8>, tx: &mut Transaction, _account: Account, _client: &mut WebSocket<TcpStream>) -> Result<RpcResponse, Error> {
let response = RpcResponse {
method: "instance_list".to_string(),
params: RpcResult::InstanceList(instance_list(tx)?)
};
return Ok(response);
}
// fn instance_ready(data: Vec<u8>, tx: &mut Transaction, account: Account, _client: &mut WebSocket<TcpStream>) -> Result<RpcResponse, Error> {
// let msg = from_slice::<InstanceReadyMsg>(&data).or(Err(err_msg("invalid params")))?;
@@ -295,7 +305,7 @@ impl Rpc {
}
}
fn player_vbox_accept(data: Vec<u8>, tx: &mut Transaction, account: Account, _client: &mut WebSocket<TcpStream>) -> Result<RpcResponse, Error> {
fn vbox_accept(data: Vec<u8>, tx: &mut Transaction, account: Account, _client: &mut WebSocket<TcpStream>) -> Result<RpcResponse, Error> {
let msg = from_slice::<VboxAcceptMsg>(&data).or(Err(err_msg("invalid params")))?;
let response = RpcResponse {
@@ -306,7 +316,7 @@ impl Rpc {
return Ok(response);
}
fn player_vbox_discard(data: Vec<u8>, tx: &mut Transaction, account: Account, _client: &mut WebSocket<TcpStream>) -> Result<RpcResponse, Error> {
fn vbox_discard(data: Vec<u8>, tx: &mut Transaction, account: Account, _client: &mut WebSocket<TcpStream>) -> Result<RpcResponse, Error> {
let msg = from_slice::<VboxDiscardMsg>(&data).or(Err(err_msg("invalid params")))?;
let response = RpcResponse {
@@ -318,7 +328,7 @@ impl Rpc {
}
fn player_vbox_combine(data: Vec<u8>, tx: &mut Transaction, account: Account, _client: &mut WebSocket<TcpStream>) -> Result<RpcResponse, Error> {
fn vbox_combine(data: Vec<u8>, tx: &mut Transaction, account: Account, _client: &mut WebSocket<TcpStream>) -> Result<RpcResponse, Error> {
let msg = from_slice::<VboxCombineMsg>(&data).or(Err(err_msg("invalid params")))?;
let response = RpcResponse {
@@ -329,7 +339,7 @@ impl Rpc {
return Ok(response);
}
fn player_vbox_apply(data: Vec<u8>, tx: &mut Transaction, account: Account, _client: &mut WebSocket<TcpStream>) -> Result<RpcResponse, Error> {
fn vbox_apply(data: Vec<u8>, tx: &mut Transaction, account: Account, _client: &mut WebSocket<TcpStream>) -> Result<RpcResponse, Error> {
let msg = from_slice::<VboxApplyMsg>(&data).or(Err(err_msg("invalid params")))?;
let response = RpcResponse {
@@ -340,7 +350,7 @@ impl Rpc {
return Ok(response);
}
fn player_vbox_reclaim(data: Vec<u8>, tx: &mut Transaction, account: Account, _client: &mut WebSocket<TcpStream>) -> Result<RpcResponse, Error> {
fn vbox_reclaim(data: Vec<u8>, tx: &mut Transaction, account: Account, _client: &mut WebSocket<TcpStream>) -> Result<RpcResponse, Error> {
let msg = from_slice::<VboxReclaimMsg>(&data).or(Err(err_msg("invalid params")))?;
let response = RpcResponse {
@@ -351,7 +361,7 @@ impl Rpc {
return Ok(response);
}
fn player_vbox_unequip(data: Vec<u8>, tx: &mut Transaction, account: Account, _client: &mut WebSocket<TcpStream>) -> Result<RpcResponse, Error> {
fn vbox_unequip(data: Vec<u8>, tx: &mut Transaction, account: Account, _client: &mut WebSocket<TcpStream>) -> Result<RpcResponse, Error> {
let msg = from_slice::<VboxUnequipMsg>(&data).or(Err(err_msg("invalid params")))?;
let response = RpcResponse {