remote_backend/src
remote_frontend/src
79
remote_backend/src/controllers/group_controller.rs
Normal file
79
remote_backend/src/controllers/group_controller.rs
Normal file
@ -0,0 +1,79 @@
|
||||
use crate::controllers::HttpResult;
|
||||
use crate::virtweb_client;
|
||||
use crate::virtweb_client::{GroupID, VMUuid};
|
||||
use actix_web::{web, HttpResponse};
|
||||
|
||||
#[derive(serde::Deserialize)]
|
||||
pub struct GroupIDInPath {
|
||||
gid: GroupID,
|
||||
}
|
||||
|
||||
#[derive(serde::Deserialize)]
|
||||
pub struct VMIDInQuery {
|
||||
vm_id: Option<VMUuid>,
|
||||
}
|
||||
|
||||
/// Get the state of one or all VM
|
||||
pub async fn vm_state(
|
||||
path: web::Path<GroupIDInPath>,
|
||||
query: web::Query<VMIDInQuery>,
|
||||
) -> HttpResult {
|
||||
Ok(HttpResponse::Ok().json(virtweb_client::group_vm_state(&path.gid, query.vm_id).await?))
|
||||
}
|
||||
|
||||
/// Start one or all VM
|
||||
pub async fn vm_start(
|
||||
path: web::Path<GroupIDInPath>,
|
||||
query: web::Query<VMIDInQuery>,
|
||||
) -> HttpResult {
|
||||
Ok(HttpResponse::Ok().json(virtweb_client::group_vm_start(&path.gid, query.vm_id).await?))
|
||||
}
|
||||
|
||||
/// Shutdown one or all VM
|
||||
pub async fn vm_shutdown(
|
||||
path: web::Path<GroupIDInPath>,
|
||||
query: web::Query<VMIDInQuery>,
|
||||
) -> HttpResult {
|
||||
Ok(HttpResponse::Ok().json(virtweb_client::group_vm_shutdown(&path.gid, query.vm_id).await?))
|
||||
}
|
||||
|
||||
/// Kill one or all VM
|
||||
pub async fn vm_kill(path: web::Path<GroupIDInPath>, query: web::Query<VMIDInQuery>) -> HttpResult {
|
||||
Ok(HttpResponse::Ok().json(virtweb_client::group_vm_kill(&path.gid, query.vm_id).await?))
|
||||
}
|
||||
|
||||
/// Reset one or all VM
|
||||
pub async fn vm_reset(
|
||||
path: web::Path<GroupIDInPath>,
|
||||
query: web::Query<VMIDInQuery>,
|
||||
) -> HttpResult {
|
||||
Ok(HttpResponse::Ok().json(virtweb_client::group_vm_reset(&path.gid, query.vm_id).await?))
|
||||
}
|
||||
|
||||
/// Suspend one or all VM
|
||||
pub async fn vm_suspend(
|
||||
path: web::Path<GroupIDInPath>,
|
||||
query: web::Query<VMIDInQuery>,
|
||||
) -> HttpResult {
|
||||
Ok(HttpResponse::Ok().json(virtweb_client::group_vm_suspend(&path.gid, query.vm_id).await?))
|
||||
}
|
||||
|
||||
/// Resume one or all VM
|
||||
pub async fn vm_resume(
|
||||
path: web::Path<GroupIDInPath>,
|
||||
query: web::Query<VMIDInQuery>,
|
||||
) -> HttpResult {
|
||||
Ok(HttpResponse::Ok().json(virtweb_client::group_vm_resume(&path.gid, query.vm_id).await?))
|
||||
}
|
||||
|
||||
/// Screenshot one or all VM
|
||||
pub async fn vm_screenshot(
|
||||
path: web::Path<GroupIDInPath>,
|
||||
query: web::Query<VMIDInQuery>,
|
||||
) -> HttpResult {
|
||||
let screenshot = virtweb_client::group_vm_screenshot(&path.gid, query.vm_id).await?;
|
||||
|
||||
Ok(HttpResponse::Ok()
|
||||
.insert_header(("content-type", "image/png"))
|
||||
.body(screenshot))
|
||||
}
|
@ -6,6 +6,7 @@ use std::fmt::{Display, Formatter};
|
||||
use std::io::ErrorKind;
|
||||
|
||||
pub mod auth_controller;
|
||||
pub mod group_controller;
|
||||
pub mod server_controller;
|
||||
pub mod static_controller;
|
||||
pub mod sys_info_controller;
|
||||
|
@ -2,7 +2,7 @@ use crate::app_config::AppConfig;
|
||||
use crate::controllers::HttpResult;
|
||||
use crate::extractors::auth_extractor::AuthExtractor;
|
||||
use crate::virtweb_client;
|
||||
use crate::virtweb_client::VMUuid;
|
||||
use crate::virtweb_client::{GroupID, VMCaps, VMInfo};
|
||||
use actix_web::HttpResponse;
|
||||
|
||||
#[derive(serde::Serialize)]
|
||||
@ -20,54 +20,70 @@ pub async fn config(auth: AuthExtractor) -> HttpResult {
|
||||
|
||||
#[derive(Default, Debug, serde::Serialize)]
|
||||
pub struct Rights {
|
||||
groups: Vec<GroupInfo>,
|
||||
vms: Vec<VMInfoAndCaps>,
|
||||
sys_info: bool,
|
||||
}
|
||||
|
||||
#[derive(Debug, serde::Serialize)]
|
||||
pub struct GroupInfo {
|
||||
id: GroupID,
|
||||
vms: Vec<VMInfo>,
|
||||
#[serde(flatten)]
|
||||
caps: VMCaps,
|
||||
}
|
||||
|
||||
#[derive(Debug, serde::Serialize)]
|
||||
pub struct VMInfoAndCaps {
|
||||
uiid: VMUuid,
|
||||
name: String,
|
||||
description: Option<String>,
|
||||
architecture: String,
|
||||
memory: usize,
|
||||
number_vcpu: usize,
|
||||
can_get_state: bool,
|
||||
can_start: bool,
|
||||
can_shutdown: bool,
|
||||
can_kill: bool,
|
||||
can_reset: bool,
|
||||
can_suspend: bool,
|
||||
can_resume: bool,
|
||||
can_screenshot: bool,
|
||||
#[serde(flatten)]
|
||||
info: VMInfo,
|
||||
#[serde(flatten)]
|
||||
caps: VMCaps,
|
||||
}
|
||||
|
||||
pub async fn rights() -> HttpResult {
|
||||
let rights = virtweb_client::get_token_info().await?;
|
||||
|
||||
let mut res = Rights {
|
||||
groups: vec![],
|
||||
vms: vec![],
|
||||
sys_info: rights.can_retrieve_system_info(),
|
||||
};
|
||||
|
||||
for g in rights.list_groups() {
|
||||
let group_vms = virtweb_client::group_vm_info(&g).await?;
|
||||
|
||||
res.groups.push(GroupInfo {
|
||||
id: g.clone(),
|
||||
vms: group_vms,
|
||||
caps: VMCaps {
|
||||
can_get_state: rights.is_route_allowed("GET", &g.route_vm_state(None)),
|
||||
can_start: rights.is_route_allowed("GET", &g.route_vm_start(None)),
|
||||
can_shutdown: rights.is_route_allowed("GET", &g.route_vm_shutdown(None)),
|
||||
can_kill: rights.is_route_allowed("GET", &g.route_vm_kill(None)),
|
||||
can_reset: rights.is_route_allowed("GET", &g.route_vm_reset(None)),
|
||||
can_suspend: rights.is_route_allowed("GET", &g.route_vm_suspend(None)),
|
||||
can_resume: rights.is_route_allowed("GET", &g.route_vm_resume(None)),
|
||||
can_screenshot: rights.is_route_allowed("GET", &g.route_vm_screenshot(None)),
|
||||
},
|
||||
})
|
||||
}
|
||||
|
||||
for v in rights.list_vm() {
|
||||
let vm_info = virtweb_client::vm_info(v).await?;
|
||||
|
||||
res.vms.push(VMInfoAndCaps {
|
||||
uiid: vm_info.uuid,
|
||||
name: vm_info.name,
|
||||
description: vm_info.description.clone(),
|
||||
architecture: vm_info.architecture.to_string(),
|
||||
memory: vm_info.memory,
|
||||
number_vcpu: vm_info.number_vcpu,
|
||||
can_get_state: rights.is_route_allowed("GET", &v.route_state()),
|
||||
can_start: rights.is_route_allowed("GET", &v.route_start()),
|
||||
can_shutdown: rights.is_route_allowed("GET", &v.route_shutdown()),
|
||||
can_kill: rights.is_route_allowed("GET", &v.route_kill()),
|
||||
can_reset: rights.is_route_allowed("GET", &v.route_reset()),
|
||||
can_suspend: rights.is_route_allowed("GET", &v.route_suspend()),
|
||||
can_resume: rights.is_route_allowed("GET", &v.route_resume()),
|
||||
can_screenshot: rights.is_route_allowed("GET", &v.route_screenshot()),
|
||||
info: vm_info,
|
||||
caps: VMCaps {
|
||||
can_get_state: rights.is_route_allowed("GET", &v.route_state()),
|
||||
can_start: rights.is_route_allowed("GET", &v.route_start()),
|
||||
can_shutdown: rights.is_route_allowed("GET", &v.route_shutdown()),
|
||||
can_kill: rights.is_route_allowed("GET", &v.route_kill()),
|
||||
can_reset: rights.is_route_allowed("GET", &v.route_reset()),
|
||||
can_suspend: rights.is_route_allowed("GET", &v.route_suspend()),
|
||||
can_resume: rights.is_route_allowed("GET", &v.route_resume()),
|
||||
can_screenshot: rights.is_route_allowed("GET", &v.route_screenshot()),
|
||||
},
|
||||
})
|
||||
}
|
||||
|
||||
|
@ -12,7 +12,8 @@ use light_openid::basic_state_manager::BasicStateManager;
|
||||
use remote_backend::app_config::AppConfig;
|
||||
use remote_backend::constants;
|
||||
use remote_backend::controllers::{
|
||||
auth_controller, server_controller, static_controller, sys_info_controller, vm_controller,
|
||||
auth_controller, group_controller, server_controller, static_controller, sys_info_controller,
|
||||
vm_controller,
|
||||
};
|
||||
use remote_backend::middlewares::auth_middleware::AuthChecker;
|
||||
use std::time::Duration;
|
||||
@ -86,6 +87,39 @@ async fn main() -> std::io::Result<()> {
|
||||
"/api/server/rights",
|
||||
web::get().to(server_controller::rights),
|
||||
)
|
||||
// Groups routes
|
||||
.route(
|
||||
"/api/group/{gid}/vm/state",
|
||||
web::get().to(group_controller::vm_state),
|
||||
)
|
||||
.route(
|
||||
"/api/group/{gid}/vm/start",
|
||||
web::get().to(group_controller::vm_start),
|
||||
)
|
||||
.route(
|
||||
"/api/group/{gid}/vm/shutdown",
|
||||
web::get().to(group_controller::vm_shutdown),
|
||||
)
|
||||
.route(
|
||||
"/api/group/{gid}/vm/kill",
|
||||
web::get().to(group_controller::vm_kill),
|
||||
)
|
||||
.route(
|
||||
"/api/group/{gid}/vm/reset",
|
||||
web::get().to(group_controller::vm_reset),
|
||||
)
|
||||
.route(
|
||||
"/api/group/{gid}/vm/suspend",
|
||||
web::get().to(group_controller::vm_suspend),
|
||||
)
|
||||
.route(
|
||||
"/api/group/{gid}/vm/resume",
|
||||
web::get().to(group_controller::vm_resume),
|
||||
)
|
||||
.route(
|
||||
"/api/group/{gid}/vm/screenshot",
|
||||
web::get().to(group_controller::vm_screenshot),
|
||||
)
|
||||
// VM routes
|
||||
.route("/api/vm/{uid}/state", web::get().to(vm_controller::state))
|
||||
.route("/api/vm/{uid}/start", web::get().to(vm_controller::start))
|
||||
|
@ -1,6 +1,7 @@
|
||||
use crate::app_config::AppConfig;
|
||||
use crate::utils::time;
|
||||
use lazy_regex::regex;
|
||||
use std::collections::HashMap;
|
||||
use std::fmt::Display;
|
||||
use std::str::FromStr;
|
||||
use thiserror::Error;
|
||||
@ -12,9 +13,105 @@ pub enum VirtWebClientError {
|
||||
InvalidStatusCode(u16),
|
||||
}
|
||||
|
||||
#[derive(Eq, PartialEq, Debug, Copy, Clone, serde::Serialize, serde::Deserialize)]
|
||||
#[derive(Eq, PartialEq, Debug, Clone, serde::Serialize, serde::Deserialize)]
|
||||
pub struct GroupID(String);
|
||||
|
||||
impl GroupID {
|
||||
pub fn route_vm_info(&self) -> String {
|
||||
format!("/api/group/{}/vm/info", self.0)
|
||||
}
|
||||
|
||||
pub fn route_vm_state(&self, vm: Option<VMUuid>) -> String {
|
||||
format!(
|
||||
"/api/group/{}/vm/state{}",
|
||||
self.0,
|
||||
match vm {
|
||||
None => "".to_string(),
|
||||
Some(id) => format!("?vm_id={}", id.0),
|
||||
}
|
||||
)
|
||||
}
|
||||
pub fn route_vm_start(&self, vm: Option<VMUuid>) -> String {
|
||||
format!(
|
||||
"/api/group/{}/vm/start{}",
|
||||
self.0,
|
||||
match vm {
|
||||
None => "".to_string(),
|
||||
Some(id) => format!("?vm_id={}", id.0),
|
||||
}
|
||||
)
|
||||
}
|
||||
pub fn route_vm_shutdown(&self, vm: Option<VMUuid>) -> String {
|
||||
format!(
|
||||
"/api/group/{}/vm/shutdown{}",
|
||||
self.0,
|
||||
match vm {
|
||||
None => "".to_string(),
|
||||
Some(id) => format!("?vm_id={}", id.0),
|
||||
}
|
||||
)
|
||||
}
|
||||
pub fn route_vm_suspend(&self, vm: Option<VMUuid>) -> String {
|
||||
format!(
|
||||
"/api/group/{}/vm/suspend{}",
|
||||
self.0,
|
||||
match vm {
|
||||
None => "".to_string(),
|
||||
Some(id) => format!("?vm_id={}", id.0),
|
||||
}
|
||||
)
|
||||
}
|
||||
pub fn route_vm_resume(&self, vm: Option<VMUuid>) -> String {
|
||||
format!(
|
||||
"/api/group/{}/vm/resume{}",
|
||||
self.0,
|
||||
match vm {
|
||||
None => "".to_string(),
|
||||
Some(id) => format!("?vm_id={}", id.0),
|
||||
}
|
||||
)
|
||||
}
|
||||
pub fn route_vm_kill(&self, vm: Option<VMUuid>) -> String {
|
||||
format!(
|
||||
"/api/group/{}/vm/kill{}",
|
||||
self.0,
|
||||
match vm {
|
||||
None => "".to_string(),
|
||||
Some(id) => format!("?vm_id={}", id.0),
|
||||
}
|
||||
)
|
||||
}
|
||||
pub fn route_vm_reset(&self, vm: Option<VMUuid>) -> String {
|
||||
format!(
|
||||
"/api/group/{}/vm/reset{}",
|
||||
self.0,
|
||||
match vm {
|
||||
None => "".to_string(),
|
||||
Some(id) => format!("?vm_id={}", id.0),
|
||||
}
|
||||
)
|
||||
}
|
||||
pub fn route_vm_screenshot(&self, vm: Option<VMUuid>) -> String {
|
||||
format!(
|
||||
"/api/group/{}/vm/screenshot{}",
|
||||
self.0,
|
||||
match vm {
|
||||
None => "".to_string(),
|
||||
Some(id) => format!("?vm_id={}", id.0),
|
||||
}
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Eq, PartialEq, Debug, Copy, Clone, serde::Serialize, serde::Deserialize, Hash)]
|
||||
pub struct VMUuid(Uuid);
|
||||
|
||||
#[derive(Default, serde::Deserialize, serde::Serialize)]
|
||||
pub struct TreatmentResult {
|
||||
ok: usize,
|
||||
failed: usize,
|
||||
}
|
||||
|
||||
impl VMUuid {
|
||||
pub fn route_info(&self) -> String {
|
||||
format!("/api/vm/{}", self.0)
|
||||
@ -69,7 +166,7 @@ pub struct TokenClaims {
|
||||
pub nonce: String,
|
||||
}
|
||||
|
||||
#[derive(serde::Deserialize, Debug)]
|
||||
#[derive(serde::Deserialize, serde::Serialize, Debug)]
|
||||
pub struct VMInfo {
|
||||
pub uuid: VMUuid,
|
||||
pub name: String,
|
||||
@ -79,6 +176,18 @@ pub struct VMInfo {
|
||||
pub number_vcpu: usize,
|
||||
}
|
||||
|
||||
#[derive(serde::Deserialize, serde::Serialize, Debug)]
|
||||
pub struct VMCaps {
|
||||
pub can_get_state: bool,
|
||||
pub can_start: bool,
|
||||
pub can_shutdown: bool,
|
||||
pub can_kill: bool,
|
||||
pub can_reset: bool,
|
||||
pub can_suspend: bool,
|
||||
pub can_resume: bool,
|
||||
pub can_screenshot: bool,
|
||||
}
|
||||
|
||||
#[derive(serde::Deserialize, serde::Serialize, Debug)]
|
||||
pub struct VMState {
|
||||
pub state: String,
|
||||
@ -147,6 +256,16 @@ impl TokenInfo {
|
||||
false
|
||||
}
|
||||
|
||||
/// List the groups with access
|
||||
pub fn list_groups(&self) -> Vec<GroupID> {
|
||||
self.rights
|
||||
.iter()
|
||||
.filter(|r| r.verb == "GET")
|
||||
.filter(|r| regex!("^/api/group/[^/]+/vm/info$").is_match(&r.path))
|
||||
.map(|r| GroupID(r.path.split("/").nth(3).unwrap().to_string()))
|
||||
.collect::<Vec<_>>()
|
||||
}
|
||||
|
||||
/// List the virtual machines with access
|
||||
pub fn list_vm(&self) -> Vec<VMUuid> {
|
||||
self.rights
|
||||
@ -168,12 +287,13 @@ async fn request<D: Display>(uri: D) -> anyhow::Result<reqwest::Response> {
|
||||
let url = format!("{}{}", AppConfig::get().virtweb_base_url, uri);
|
||||
log::debug!("Will query {uri}...");
|
||||
|
||||
let uri = uri.to_string();
|
||||
let jwt = TokenClaims {
|
||||
sub: AppConfig::get().virtweb_token_id.to_string(),
|
||||
iat: time() - 60 * 2,
|
||||
exp: time() + 60 * 3,
|
||||
verb: "GET".to_string(),
|
||||
path: uri.to_string(),
|
||||
path: uri.split_once('?').map(|s| s.0).unwrap_or(&uri).to_string(),
|
||||
nonce: Uuid::new_v4().to_string(),
|
||||
};
|
||||
let jwt = AppConfig::get().token_private_key().sign_jwt(&jwt)?;
|
||||
@ -260,6 +380,73 @@ pub async fn vm_screenshot(id: VMUuid) -> anyhow::Result<Vec<u8>> {
|
||||
.to_vec())
|
||||
}
|
||||
|
||||
/// Get the VM of a group
|
||||
pub async fn group_vm_info(id: &GroupID) -> anyhow::Result<Vec<VMInfo>> {
|
||||
json_request(id.route_vm_info()).await
|
||||
}
|
||||
|
||||
/// Get the state of one or all VMs of a group
|
||||
pub async fn group_vm_state(
|
||||
id: &GroupID,
|
||||
vm_id: Option<VMUuid>,
|
||||
) -> anyhow::Result<HashMap<VMUuid, String>> {
|
||||
json_request(id.route_vm_state(vm_id)).await
|
||||
}
|
||||
|
||||
/// Start one or all VMs of a group
|
||||
pub async fn group_vm_start(
|
||||
id: &GroupID,
|
||||
vm_id: Option<VMUuid>,
|
||||
) -> anyhow::Result<TreatmentResult> {
|
||||
json_request(id.route_vm_start(vm_id)).await
|
||||
}
|
||||
|
||||
/// Shutdown one or all VMs of a group
|
||||
pub async fn group_vm_shutdown(
|
||||
id: &GroupID,
|
||||
vm_id: Option<VMUuid>,
|
||||
) -> anyhow::Result<TreatmentResult> {
|
||||
json_request(id.route_vm_shutdown(vm_id)).await
|
||||
}
|
||||
|
||||
/// Kill one or all VMs of a group
|
||||
pub async fn group_vm_kill(id: &GroupID, vm_id: Option<VMUuid>) -> anyhow::Result<TreatmentResult> {
|
||||
json_request(id.route_vm_kill(vm_id)).await
|
||||
}
|
||||
|
||||
/// Reset one or all VMs of a group
|
||||
pub async fn group_vm_reset(
|
||||
id: &GroupID,
|
||||
vm_id: Option<VMUuid>,
|
||||
) -> anyhow::Result<TreatmentResult> {
|
||||
json_request(id.route_vm_reset(vm_id)).await
|
||||
}
|
||||
|
||||
/// Suspend one or all VMs of a group
|
||||
pub async fn group_vm_suspend(
|
||||
id: &GroupID,
|
||||
vm_id: Option<VMUuid>,
|
||||
) -> anyhow::Result<TreatmentResult> {
|
||||
json_request(id.route_vm_suspend(vm_id)).await
|
||||
}
|
||||
|
||||
/// Resume one or all VMs of a group
|
||||
pub async fn group_vm_resume(
|
||||
id: &GroupID,
|
||||
vm_id: Option<VMUuid>,
|
||||
) -> anyhow::Result<TreatmentResult> {
|
||||
json_request(id.route_vm_resume(vm_id)).await
|
||||
}
|
||||
|
||||
/// Get the screenshot of one or all VMs of a group
|
||||
pub async fn group_vm_screenshot(id: &GroupID, vm_id: Option<VMUuid>) -> anyhow::Result<Vec<u8>> {
|
||||
Ok(request(id.route_vm_screenshot(vm_id))
|
||||
.await?
|
||||
.bytes()
|
||||
.await?
|
||||
.to_vec())
|
||||
}
|
||||
|
||||
/// Get current server information
|
||||
pub async fn get_server_info() -> anyhow::Result<SystemInfo> {
|
||||
json_request("/api/server/info").await
|
||||
|
Reference in New Issue
Block a user