self.chan.write(&cmd).context("send command")?;
let resp = self.chan.read().context("read response")?;
match &resp {
- Fine{..} | GamesList{..} => { },
+ Fine | GamesList{..} => { },
AlterGame { error: None, .. } => { },
Error { error } => {
Err(error.clone()).context(format!("response to: {:?}",&cmd))?;
let unix = UnixStream::connect(SOCKET_PATH).context("connect to server")?;
let chan = MgmtChannel::new(unix)?;
let mut chan = Conn { chan };
- chan.cmd(&MgmtCommand::SetScope { scope: ma.scope.clone().unwrap() })?;
+ chan.cmd(&MgmtCommand::SetScope(ma.scope.clone().unwrap()))?;
chan
}
players: resetreport.clone(),
});
insns.push(MgmtGameInstruction::ReportPlayerAccesses {
+ // xxx not needed
players: resetreport.clone(),
});
let mut got_tokens = None;
chan.alter_game(insns, &mut |response| {
- if let MgmtGameResponse::PlayerAccessTokens { tokens } = response {
+ if let MgmtGameResponse::PlayerAccessTokens(tokens) = response {
got_tokens = Some(tokens.clone());
}
Ok(())
eprintln!("command connection {}: executing {:?}", &cs.desc, &cmd);
match cmd {
- Noop { } => Fine { },
+ Noop => Fine,
- SetScope{ scope: wanted_scope } => {
+ SetScope(wanted_scope) => {
let authorised : AuthorisedSatisfactory =
authorise_scope(cs, &wanted_scope)?;
cs.scope = Some(authorised.into_inner());
- Fine { }
+ Fine
},
CreateGame { name, insns } => {
e
})?;
- Fine { }
+ Fine
},
ListGames { all } => {
};
let mut games = Instance::list_names(scope);
games.sort_unstable();
- GamesList { games }
+ GamesList(games)
},
MgmtCommand::AlterGame { name, insns, how} => {
use MgmtGameInstruction::*;
use MgmtGameResponse::*;
match update {
- Noop { } => (vec![], vec![], Fine { }),
+ Noop { } => (vec![], vec![], Fine),
MgmtGameInstruction::AddPlayer(pl) => {
let player = ig.player_new(pl)?;
RemovePlayer(player) => {
ig.player_remove(player)?;
- (vec![], vec![], Fine{})
+ (vec![], vec![], Fine)
},
GetPlayers { } => {
ResetPlayerAccesses { players } => {
let tokens = ig.players_access_reset(&players)?
.drain(0..).map(|token| vec![token]).collect();
- (vec![], vec![], PlayerAccessTokens { tokens })
+ (vec![], vec![], PlayerAccessTokens(tokens))
}
ReportPlayerAccesses { players } => {
let tokens = ig.players_access_report(&players)?;
- (vec![], vec![], PlayerAccessTokens { tokens })
+ (vec![], vec![], PlayerAccessTokens(tokens))
}
SetFixedPlayerAccess { player, token } => {
ig.player_access_register_fixed(
player, token, authorised
)?;
- (vec![], vec![], Fine{})
+ (vec![], vec![], Fine)
}
AddPiece(PiecesSpec{ pos,posd,count,face,info }) => {
(updates, vec![ LogEntry {
html: format!("The facilitaror added {} pieces", count),
}],
- Fine { }
+ Fine
)
},
}
#[derive(Debug,Serialize,Deserialize)]
pub enum MgmtCommand {
- Noop { },
- SetScope { scope: ManagementScope },
+ Noop,
+ SetScope(ManagementScope),
CreateGame { name: String, insns: Vec<MgmtGameInstruction> },
ListGames { all: Option<bool>, },
AlterGame {
#[derive(Debug,Serialize,Deserialize)]
pub enum MgmtResponse {
- Fine { },
+ Fine,
Error { error: MgmtError },
AlterGame { error: Option<MgmtError>, responses: Vec<MgmtGameResponse> },
- GamesList { games: Vec<Arc<InstanceName>> },
+ GamesList(Vec<Arc<InstanceName>>),
}
#[derive(Debug,Serialize,Deserialize)]
pub enum MgmtGameInstruction {
- Noop { },
+ Noop,
AddPiece(PiecesSpec),
// todo: RemovePiece
AddPlayer(PlayerState),
#[derive(Debug,Serialize,Deserialize)]
pub enum MgmtGameResponse {
- Fine { },
+ Fine,
AddPlayer(PlayerId),
- PlayerAccessTokens { tokens: Vec<Vec<RawToken>> },
+ PlayerAccessTokens(Vec<Vec<RawToken>>),
Players(PlayerMap),
}