rpc calls!!!
parent
58eba9a315
commit
7411bb5972
GPG Key ID:
AD2560A0F84F0759
@ -0,0 +1,101 @@
|
||||
use serde::{Deserialize, Serialize};
|
||||
use std::fmt::Debug;
|
||||
use paste::paste;
|
||||
use crate::rpc::{Request, Response};
|
||||
use crate::VirtualMachineInfo;
|
||||
|
||||
macro_rules! define_requests {
|
||||
($($name:ident($req:tt, $resp:tt))+) => {
|
||||
#[derive(Clone, Debug, Serialize, Deserialize)]
|
||||
#[serde(tag = "query", rename_all = "snake_case")]
|
||||
pub enum AllRequests {
|
||||
$($name(paste! { [<$name Request >] })),+
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Serialize, Deserialize)]
|
||||
#[serde(untagged, rename_all = "snake_case")]
|
||||
pub enum AllResponses {
|
||||
$($name(paste! { [<$name Response >] })),+
|
||||
}
|
||||
|
||||
$(
|
||||
paste! {
|
||||
#[derive(Clone, Debug, Serialize, Deserialize)]
|
||||
pub struct [<$name Request>] $req
|
||||
#[derive(Clone, Debug, Serialize, Deserialize)]
|
||||
pub struct [<$name Response>] $resp
|
||||
|
||||
impl Request for [<$name Request>] {
|
||||
type Response = [<$name Response>];
|
||||
|
||||
fn into_enum(self) -> AllRequests {
|
||||
AllRequests::$name(self)
|
||||
}
|
||||
}
|
||||
|
||||
impl Response for [<$name Response>] {
|
||||
fn into_enum(self) -> AllResponses {
|
||||
AllResponses::$name(self)
|
||||
}
|
||||
}
|
||||
}
|
||||
)+
|
||||
};
|
||||
}
|
||||
|
||||
impl Request for AllRequests {
|
||||
type Response = AllResponses;
|
||||
|
||||
fn into_enum(self) -> AllRequests {
|
||||
self
|
||||
}
|
||||
}
|
||||
|
||||
impl Response for AllResponses {
|
||||
fn into_enum(self) -> AllResponses {
|
||||
self
|
||||
}
|
||||
}
|
||||
|
||||
define_requests! {
|
||||
Info({}, {
|
||||
pub name: String,
|
||||
pub version: String
|
||||
})
|
||||
|
||||
List({}, {
|
||||
pub items: Vec<VirtualMachineInfo>
|
||||
})
|
||||
|
||||
Load({
|
||||
pub toml: String,
|
||||
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||
pub cdroms: Vec<String>,
|
||||
#[serde(default)]
|
||||
pub save: bool,
|
||||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||
pub working_directory: Option<String>,
|
||||
}, {
|
||||
pub info: VirtualMachineInfo,
|
||||
})
|
||||
|
||||
Prepare({
|
||||
pub name: String,
|
||||
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||
pub cdroms: Vec<String>,
|
||||
}, {})
|
||||
|
||||
Start({
|
||||
pub name: String,
|
||||
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||
pub cdroms: Vec<String>,
|
||||
}, {})
|
||||
|
||||
Stop({
|
||||
pub name: String,
|
||||
}, {})
|
||||
|
||||
Unload({
|
||||
pub name: String,
|
||||
}, {})
|
||||
}
|
||||
@ -0,0 +1,7 @@
|
||||
mod calls;
|
||||
mod serde;
|
||||
mod traits;
|
||||
|
||||
pub use calls::*;
|
||||
pub use crate::rpc::serde::*;
|
||||
pub use traits::*;
|
||||
@ -0,0 +1,72 @@
|
||||
use crate::rpc::{Command, Request, Answer, AnswerResult, AnswerError, Response};
|
||||
use std::fmt::{Display, Formatter};
|
||||
use std::fmt;
|
||||
use std::error::Error;
|
||||
|
||||
#[derive(Debug, Default)]
|
||||
pub struct CommandCenter {
|
||||
id: u64,
|
||||
}
|
||||
|
||||
impl CommandCenter {
|
||||
pub fn write_command<R: Request>(&mut self, request: R) -> Result<(u64, String), anyhow::Error> {
|
||||
let command = Command {
|
||||
id: self.id,
|
||||
data: request.into_enum(),
|
||||
};
|
||||
|
||||
self.id += 1;
|
||||
|
||||
let mut str = serde_json::to_string(&command)?;
|
||||
str.push('\n');
|
||||
Ok((command.id, str))
|
||||
}
|
||||
|
||||
pub fn write_answer<R: Response>(request: &Command, answer: Result<R, anyhow::Error>) -> Result<String, anyhow::Error> {
|
||||
let answer = Answer {
|
||||
id: request.id,
|
||||
data: match answer {
|
||||
Ok(data) => AnswerResult::Ok(data),
|
||||
Err(err) => AnswerResult::Error(AnswerError {
|
||||
error: format!("{:?}", err)
|
||||
})
|
||||
},
|
||||
};
|
||||
|
||||
let mut str = serde_json::to_string(&answer)?;
|
||||
str.push('\n');
|
||||
return Ok(str);
|
||||
}
|
||||
|
||||
pub fn read_command(request: &str) -> Result<Command, anyhow::Error> {
|
||||
serde_json::from_str(request).map_err(From::from)
|
||||
}
|
||||
|
||||
pub fn read_answer<R: Request>(answer: &str) -> Result<(u64, R::Response), CommandError> {
|
||||
let answer_obj: Answer<R::Response> = serde_json::from_str(answer).map_err(|err| CommandError::InternalError(err.into()))?;
|
||||
|
||||
match answer_obj.data {
|
||||
AnswerResult::Error(err) => Err(CommandError::AnswerError(answer_obj.id, err)),
|
||||
AnswerResult::Ok(data) => Ok((answer_obj.id, data))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
pub enum CommandError {
|
||||
AnswerError(u64, AnswerError),
|
||||
InternalError(anyhow::Error),
|
||||
}
|
||||
|
||||
impl Display for CommandError {
|
||||
fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
|
||||
match self {
|
||||
CommandError::AnswerError(idx, err) => {
|
||||
write!(f, "{}\n(rpc call {})", err.error, idx)
|
||||
}
|
||||
CommandError::InternalError(err) => err.fmt(f)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl Error for CommandError {}
|
||||
@ -0,0 +1,42 @@
|
||||
use serde::{Deserialize, Serialize};
|
||||
use std::fmt::Debug;
|
||||
use crate::rpc::{AllRequests, AllResponses};
|
||||
use serde::de::DeserializeOwned;
|
||||
|
||||
#[derive(Clone, Debug, Serialize, Deserialize)]
|
||||
pub struct Command {
|
||||
pub id: u64,
|
||||
#[serde(flatten)]
|
||||
pub data: AllRequests,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Serialize, Deserialize)]
|
||||
pub struct Answer<R: Response> {
|
||||
pub(crate) id: u64,
|
||||
#[serde(flatten, bound = "R: Response")]
|
||||
pub(crate) data: AnswerResult<R>,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Serialize, Deserialize)]
|
||||
#[serde(untagged)]
|
||||
pub enum AnswerResult<R: Response> {
|
||||
Error(AnswerError),
|
||||
#[serde(bound = "R: Response")]
|
||||
Ok(R),
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Serialize, Deserialize)]
|
||||
pub struct AnswerError {
|
||||
pub(crate) error: String,
|
||||
}
|
||||
|
||||
pub trait Request: Serialize + DeserializeOwned + Clone + Debug {
|
||||
type Response: Response;
|
||||
|
||||
fn into_enum(self) -> AllRequests;
|
||||
}
|
||||
|
||||
pub trait Response: Serialize + DeserializeOwned + Clone + Debug + Sized {
|
||||
fn into_enum(self) -> AllResponses;
|
||||
}
|
||||
|
||||
@ -0,0 +1,453 @@
|
||||
{
|
||||
"$schema": "http://json-schema.org/draft-07/schema#",
|
||||
"structures": {
|
||||
"arrayStrUnique": {
|
||||
"type": "array",
|
||||
"items": {
|
||||
"type": "string",
|
||||
"uniqueItems": true
|
||||
}
|
||||
},
|
||||
"optionalStr": {
|
||||
"anyOf": [
|
||||
{
|
||||
"type": "string"
|
||||
},
|
||||
{
|
||||
"type": "null"
|
||||
}
|
||||
]
|
||||
},
|
||||
"tuple2StrStr": {
|
||||
"type": "array",
|
||||
"maxLength": 2,
|
||||
"minLength": 2,
|
||||
"items": [
|
||||
{
|
||||
"type": "string"
|
||||
},
|
||||
{
|
||||
"type": "string"
|
||||
}
|
||||
]
|
||||
},
|
||||
"tuple3StrOptStrStr": {
|
||||
"type": "array",
|
||||
"maxLength": 3,
|
||||
"minLength": 3,
|
||||
"items": [
|
||||
{
|
||||
"type": "string"
|
||||
},
|
||||
{
|
||||
"$ref": "#/structures/optionalStr"
|
||||
},
|
||||
{
|
||||
"type": "string"
|
||||
}
|
||||
]
|
||||
}
|
||||
},
|
||||
"definitions": {
|
||||
"namedArg": {
|
||||
"type": "object",
|
||||
"additionalProperties": false,
|
||||
"minProperties": 1,
|
||||
"maxProperties": 1,
|
||||
"patternProperties": {
|
||||
".+": {
|
||||
"$ref": "#/definitions/arg"
|
||||
}
|
||||
}
|
||||
},
|
||||
"arg": {
|
||||
"type": "object",
|
||||
"properties": {
|
||||
"alias": {
|
||||
"type": "string"
|
||||
},
|
||||
"aliases": {
|
||||
"$ref": "#/structures/arrayStrUnique"
|
||||
},
|
||||
"allow_hyphen_values": {
|
||||
"type": "boolean"
|
||||
},
|
||||
"case_insensitive": {
|
||||
"type": "boolean"
|
||||
},
|
||||
"conflicts_with": {
|
||||
"anyOf": [
|
||||
{
|
||||
"type": "string"
|
||||
},
|
||||
{
|
||||
"$ref": "#/structures/arrayStrUnique"
|
||||
}
|
||||
]
|
||||
},
|
||||
"default_value": {
|
||||
"type": "string"
|
||||
},
|
||||
"default_values": {
|
||||
"$ref": "#/structures/arrayStrUnique"
|
||||
},
|
||||
"default_value_if": {
|
||||
"$ref": "#/structures/tuple3StrOptStrStr"
|
||||
},
|
||||
"default_value_ifs": {
|
||||
"type": "array",
|
||||
"items": {
|
||||
"$ref": "#/structures/tuple3StrOptStrStr"
|
||||
}
|
||||
},
|
||||
"display_order": {
|
||||
"type": "integer"
|
||||
},
|
||||
"env": {
|
||||
"type": "string"
|
||||
},
|
||||
"exclusive": {
|
||||
"type": "boolean"
|
||||
},
|
||||
"global": {
|
||||
"type": "boolean"
|
||||
},
|
||||
"group": {
|
||||
"type": "string"
|
||||
},
|
||||
"groups": {
|
||||
"$ref": "#/structures/arrayStrUnique"
|
||||
},
|
||||
"help": {
|
||||
"type": "string"
|
||||
},
|
||||
"help_heading": {
|
||||
"$ref": "#/structures/optionalStr"
|
||||
},
|
||||
"hidden": {
|
||||
"type": "boolean"
|
||||
},
|
||||
"hidden_long_help": {
|
||||
"type": "boolean"
|
||||
},
|
||||
"hidden_short_help": {
|
||||
"type": "boolean"
|
||||
},
|
||||
"hide_default_value": {
|
||||
"type": "boolean"
|
||||
},
|
||||
"hide_env_value": {
|
||||
"type": "boolean"
|
||||
},
|
||||
"hide_possible_value": {
|
||||
"type": "boolean"
|
||||
},
|
||||
"index": {
|
||||
"type": "integer"
|
||||
},
|
||||
"last": {
|
||||
"type": "boolean"
|
||||
},
|
||||
"long": {
|
||||
"type": "string"
|
||||
},
|
||||
"long_about": {
|
||||
"type": "string"
|
||||
},
|
||||
"long_help": {
|
||||
"type": "string"
|
||||
},
|
||||
"max_values": {
|
||||
"type": "integer"
|
||||
},
|
||||
"min_values": {
|
||||
"type": "integer"
|
||||
},
|
||||
"multiple": {
|
||||
"type": "boolean"
|
||||
},
|
||||
"multiple_occurences": {
|
||||
"type": "boolean"
|
||||
},
|
||||
"multiple_values": {
|
||||
"type": "boolean"
|
||||
},
|
||||
"next_line_help": {
|
||||
"type": "boolean"
|
||||
},
|
||||
"number_of_values": {
|
||||
"type": "integer"
|
||||
},
|
||||
"overrides_with": {
|
||||
"type": "string"
|
||||
},
|
||||
"overrides_with_all": {
|
||||
"$ref": "#/structures/arrayStrUnique"
|
||||
},
|
||||
"possible_value": {
|
||||
"type": "string"
|
||||
},
|
||||
"possible_values": {
|
||||
"$ref": "#/structures/arrayStrUnique"
|
||||
},
|
||||
"raw": {
|
||||
"type": "boolean"
|
||||
},
|
||||
"require_delimiter": {
|
||||
"type": "boolean"
|
||||
},
|
||||
"require_equals": {
|
||||
"type": "boolean"
|
||||
},
|
||||
"required": {
|
||||
"type": "boolean"
|
||||
},
|
||||
"required_if": {
|
||||
"$ref": "#/structures/tuple2StrStr"
|
||||
},
|
||||
"required_ifs": {
|
||||
"type": "array",
|
||||
"items": {
|
||||
"$ref": "#/structures/tuple2StrStr"
|
||||
}
|
||||
},
|
||||
"required_unless": {
|
||||
"type": "string"
|
||||
},
|
||||
"required_unless_all": {
|
||||
"$ref": "#/structures/arrayStrUnique"
|
||||
},
|
||||
"required_unless_one": {
|
||||
"$ref": "#/structures/arrayStrUnique"
|
||||
},
|
||||
"requires": {
|
||||
"type": "string"
|
||||
},
|
||||
"requires_all": {
|
||||
"$ref": "#/structures/arrayStrUnique"
|
||||
},
|
||||
"requires_if": {
|
||||
"$ref": "#/structures/tuple2StrStr"
|
||||
},
|
||||
"requires_ifs": {
|
||||
"type": "array",
|
||||
"items": {
|
||||
"$ref": "#/structures/tuple2StrStr"
|
||||
}
|
||||
},
|
||||
"setting": {
|
||||
"type": "string"
|
||||
},
|
||||
"settings": {
|
||||
"$ref": "#/structures/arrayStrUnique"
|
||||
},
|
||||
"short": {
|
||||
"$ref": "#/definitions/shortArg"
|
||||
},
|
||||
"short_alias": {
|
||||
"$ref": "#/definitions/shortArg"
|
||||
},
|
||||
"short_aliases": {
|
||||
"type": "array",
|
||||
"items": {
|
||||
"$ref": "#/definitions/shortArg"
|
||||
},
|
||||
"uniqueItems": true
|
||||
},
|
||||
"takes_value": {
|
||||
"type": "boolean"
|
||||
},
|
||||
"use_delimiter": {
|
||||
"type": "boolean"
|
||||
},
|
||||
"value_name": {
|
||||
"type": "string"
|
||||
},
|
||||
"value_names": {
|
||||
"$ref": "#/structures/arrayStrUnique"
|
||||
},
|
||||
"value_terminator": {
|
||||
"type": "string"
|
||||
},
|
||||
"value_delimiter": {
|
||||
"type": "string"
|
||||
},
|
||||
"visible_alias": {
|
||||
"type": "string"
|
||||
},
|
||||
"visible_aliases": {
|
||||
"$ref": "#/structures/arrayStrUnique"
|
||||
},
|
||||
"visible_short_alias": {
|
||||
"type": "string"
|
||||
},
|
||||
"visible_short_aliases": {
|
||||
"$ref": "#/structures/arrayStrUnique"
|
||||
}
|
||||
}
|
||||
},
|
||||
"argGroup": {
|
||||
"properties": {
|
||||
"arg": {
|
||||
"type": "string"
|
||||
},
|
||||
"args": {
|
||||
"$ref": "#/structures/arrayStrUnique"
|
||||
},
|
||||
"conflicts_with": {
|
||||
"type": "string"
|
||||
},
|
||||
"conflicts_with_all": {
|
||||
"$ref": "#/structures/arrayStrUnique"
|
||||
},
|
||||
"multiple": {
|
||||
"type": "boolean"
|
||||
},
|
||||
"required": {
|
||||
"type": "boolean"
|
||||
},
|
||||
"requires": {
|
||||
"type": "string"
|
||||
},
|
||||
"requires_all": {
|
||||
"$ref": "#/structures/arrayStrUnique"
|
||||
}
|
||||
},
|
||||
"type": "object"
|
||||
},
|
||||
"shortArg": {
|
||||
"maxLength": 1,
|
||||
"minLength": 1,
|
||||
"pattern": "^[^-]$",
|
||||
"type": "string"
|
||||
}
|
||||
},
|
||||
"type": "object",
|
||||
"TODO:": "set 'name' as required",
|
||||
"properties": {
|
||||
"about": {
|
||||
"type": "string"
|
||||
},
|
||||
"after_help": {
|
||||
"type": "string"
|
||||
},
|
||||
"alias": {
|
||||
"type": "string"
|
||||
},
|
||||
"aliases": {
|
||||
"$ref": "#/structures/arrayStrUnique"
|
||||
},
|
||||
"arg": {
|
||||
"$ref": "#/definitions/arg"
|
||||
},
|
||||
"args": {
|
||||
"type": "array",
|
||||
"items": {
|
||||
"$ref": "#/definitions/namedArg"
|
||||
}
|
||||
},
|
||||
"author": {
|
||||
"type": "string"
|
||||
},
|
||||
"before_help": {
|
||||
"type": "string"
|
||||
},
|
||||
"bin_name": {
|
||||
"type": "string"
|
||||
},
|
||||
"display_order": {
|
||||
"type": "integer"
|
||||
},
|
||||
"global_setting": {
|
||||
"type": "string"
|
||||
},
|
||||
"global_settings": {
|
||||
"$ref": "#/structures/arrayStrUnique"
|
||||
},
|
||||
"group": {
|
||||
"$ref": "#/definitions/argGroup"
|
||||
},
|
||||
"groups": {
|
||||
"type": "array",
|
||||
"items": {
|
||||
"type": "object",
|
||||
"minProperties": 1,
|
||||
"maxProperties": 1,
|
||||
"patternProperties": {
|
||||
".+": {
|
||||
"$ref": "#/definitions/argGroup"
|
||||
}
|
||||
}
|
||||
}
|
||||
},
|
||||
"help_heading": {
|
||||
"type": "string"
|
||||
},
|
||||
"help_template": {
|
||||
"type": "string"
|
||||
},
|
||||
"long_about": {
|
||||
"type": "string"
|
||||
},
|
||||
"long_version": {
|
||||
"type": "string"
|
||||
},
|
||||
"max_term_width": {
|
||||
"type": "integer"
|
||||
},
|
||||
"name": {
|
||||
"type": "string"
|
||||
},
|
||||
"override_help": {
|
||||
"type": "string"
|
||||
},
|
||||
"override_usage": {
|
||||
"type": "string"
|
||||
},
|
||||
"replace": {
|
||||
"type": "object",
|
||||
"patternProperties": {
|
||||
"^.*$": {
|
||||
"type": "array",
|
||||
"items": {
|
||||
"type": "string"
|
||||
}
|
||||
}
|
||||
}
|
||||
},
|
||||
"setting": {
|
||||
"type": "string"
|
||||
},
|
||||
"settings": {
|
||||
"$ref": "#/structures/arrayStrUnique"
|
||||
},
|
||||
"subcommand": {
|
||||
"$ref": "#"
|
||||
},
|
||||
"subcommands": {
|
||||
"type": "array",
|
||||
"items": {
|
||||
"type": "object",
|
||||
"minProperties": 1,
|
||||
"maxProperties": 1,
|
||||
"patternProperties": {
|
||||
".+": {
|
||||
"$ref": "#"
|
||||
}
|
||||
}
|
||||
}
|
||||
},
|
||||
"term_width": {
|
||||
"type": "string"
|
||||
},
|
||||
"version": {
|
||||
"type": "string"
|
||||
},
|
||||
"visible_alias": {
|
||||
"type": "string"
|
||||
},
|
||||
"visible_aliases": {
|
||||
"$ref": "#/structures/arrayStrUnique"
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,122 @@
|
||||
name: "vore"
|
||||
about: "vored management interface"
|
||||
author: "eater <=eater.me>"
|
||||
|
||||
args:
|
||||
- vored-socket:
|
||||
global: true
|
||||
help: "Connect to the specified socket"
|
||||
required: false
|
||||
takes_value: true
|
||||
default_value: "/run/vore.sock"
|
||||
long: conn
|
||||
short: c
|
||||
|
||||
settings:
|
||||
- SubcommandRequiredElseHelp
|
||||
- GlobalVersion
|
||||
|
||||
subcommands:
|
||||
- daemon:
|
||||
visible_alias: d
|
||||
setting: SubcommandRequiredElseHelp
|
||||
about: "Daemon related commands"
|
||||
subcommands:
|
||||
- version:
|
||||
about: "Get the version of the daemon"
|
||||
|
||||
- load:
|
||||
about: "Load a new VM"
|
||||
args: &loadvm
|
||||
- vm-config:
|
||||
required: true
|
||||
takes_value: true
|
||||
- cdrom:
|
||||
help: "Attach a cdrom to this configuration"
|
||||
long: cdrom
|
||||
multiple: true
|
||||
takes_value: true
|
||||
- save:
|
||||
help: "Save this VM configuration"
|
||||
long: save
|
||||
short: s
|
||||
- prepare:
|
||||
about: "Prepare a VM"
|
||||
args:
|
||||
- vm-name:
|
||||
help: "VM to prepare, if not given the ONLY loaded instance will be used"
|
||||
required: false
|
||||
takes_value: true
|
||||
- cdrom:
|
||||
help: "Attach a cdrom to this vm when starting"
|
||||
long: cdrom
|
||||
multiple: true
|
||||
takes_value: true
|
||||
- boot:
|
||||
about: "Load and boot a new VM"
|
||||
args: *loadvm
|
||||
|
||||
- start:
|
||||
about: "Start a VM"
|
||||
args:
|
||||
- vm-name:
|
||||
help: "VM to start, if not given the ONLY loaded instance will be used"
|
||||
takes_value: true
|
||||
- cdrom:
|
||||
help: "Attach a cdrom to this vm when starting"
|
||||
long: cdrom
|
||||
multiple: true
|
||||
takes_value: true
|
||||
- stop:
|
||||
about: "Stop a VM"
|
||||
args:
|
||||
- vm-name:
|
||||
help: "VM to stop, if not given the ONLY running instance will be used"
|
||||
required: false
|
||||
takes_value: true
|
||||
- list:
|
||||
about: "List loaded VMs"
|
||||
|
||||
- scream:
|
||||
setting: SubcommandRequiredElseHelp
|
||||
about: "Scream related actions"
|
||||
subcommands:
|
||||
- stop:
|
||||
about: "Stop a running scream instance"
|
||||
args:
|
||||
- vm-name:
|
||||
help: "VM to start looking glass instance for, if not given the ONLY running instance will be used"
|
||||
required: false
|
||||
takes_value: true
|
||||
- start:
|
||||
about: "Start a scream instance"
|
||||
args:
|
||||
- vm-name:
|
||||
help: "VM to start looking glass instance for, if not given the ONLY running instance will be used"
|
||||
required: false
|
||||
takes_value: true
|
||||
|
||||
|
||||
- looking-glass:
|
||||
about: "Start a looking glass instance for a VM"
|
||||
visible_alias: lg
|
||||
args:
|
||||
- vm-name:
|
||||
help: "VM to start looking glass instance for, if not given the ONLY running instance will be used"
|
||||
required: false
|
||||
takes_value: true
|
||||
- looking-glass-args:
|
||||
help: "Arguments to pass to looking glass"
|
||||
last: true
|
||||
takes_value: true
|
||||
require_delimiter: true
|
||||
multiple: true
|
||||
|
||||
- x:
|
||||
about: "Weird hidden actions"
|
||||
setting: SubcommandRequiredElseHelp
|
||||
subcommands:
|
||||
- qemucmd:
|
||||
about: "Print the qemu command that would run this vm"
|
||||
args: *loadvm
|
||||
|
||||
@ -0,0 +1,57 @@
|
||||
use std::os::unix::net::UnixStream;
|
||||
use std::path::Path;
|
||||
use vore_core::rpc::{CommandCenter, Request};
|
||||
use std::io::{BufReader, Write, BufRead};
|
||||
use vore_core::{CloneableUnixStream, VirtualMachineInfo};
|
||||
use vore_core::rpc::*;
|
||||
|
||||
pub struct Client {
|
||||
stream: CloneableUnixStream,
|
||||
buf_reader: BufReader<CloneableUnixStream>,
|
||||
center: CommandCenter,
|
||||
}
|
||||
|
||||
impl Client {
|
||||
pub fn connect<P: AsRef<Path>>(path: P) -> anyhow::Result<Client> {
|
||||
let path = path.as_ref();
|
||||
let stream = CloneableUnixStream::new(UnixStream::connect(path)?);
|
||||
log::debug!("Connected to vore socket at {}", path.to_str().unwrap());
|
||||
|
||||
Ok(Client {
|
||||
buf_reader: BufReader::new(stream.clone()),
|
||||
stream,
|
||||
center: Default::default(),
|
||||
})
|
||||
}
|
||||
|
||||
fn send<R: Request>(&mut self, request: R) -> anyhow::Result<R::Response> {
|
||||
let (_, json) = self.center.write_command(request)?;
|
||||
self.stream.write_all(json.as_bytes())?;
|
||||
let mut response = String::new();
|
||||
self.buf_reader.read_line(&mut response)?;
|
||||
let (_, info) = CommandCenter::read_answer::<R>(&response)?;
|
||||
Ok(info)
|
||||
}
|
||||
|
||||
pub fn load_vm(&mut self, toml: &str, save: bool, cdroms: Vec<String>) -> anyhow::Result<VirtualMachineInfo> {
|
||||
Ok(self.send(LoadRequest {
|
||||
cdroms,
|
||||
save,
|
||||
toml: toml.to_string(),
|
||||
working_directory: None,
|
||||
})?.info)
|
||||
}
|
||||
|
||||
pub fn list_vms(&mut self) -> anyhow::Result<Vec<VirtualMachineInfo>> {
|
||||
Ok(self.send(ListRequest {})?.items)
|
||||
}
|
||||
|
||||
pub fn host_version(&mut self) -> anyhow::Result<InfoResponse> {
|
||||
self.send(InfoRequest {})
|
||||
}
|
||||
|
||||
pub fn prepare(&mut self, vm: String, cdroms: Vec<String>) -> anyhow::Result<()> {
|
||||
self.send(PrepareRequest { name: vm, cdroms })?;
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
@ -1,5 +1,126 @@
|
||||
use vore_core::InstanceConfig;
|
||||
mod client;
|
||||
|
||||
use vore_core::{init_logging};
|
||||
use crate::client::Client;
|
||||
use clap::{App, ArgMatches};
|
||||
use std::fs;
|
||||
use anyhow::Context;
|
||||
use std::option::Option::Some;
|
||||
|
||||
fn main() {
|
||||
let cfg = InstanceConfig::from_toml(include_str!("../../config/example.toml")).unwrap();
|
||||
init_logging();
|
||||
|
||||
if let Err(err) = main_res() {
|
||||
println!("{:?}", err)
|
||||
}
|
||||
}
|
||||
|
||||
fn main_res() -> anyhow::Result<()> {
|
||||
let yaml = clap::load_yaml!("../clap.yml");
|
||||
let app: App = App::from(yaml);
|
||||
let matches = app.get_matches();
|
||||
let client = Client::connect(matches.value_of("vored-socket").unwrap())?;
|
||||
|
||||
let mut vore = VoreApp {
|
||||
client
|
||||
};
|
||||
|
||||
match matches.subcommand() {
|
||||
("load", Some(args)) => {
|
||||
vore.load(args)?;
|
||||
}
|
||||
|
||||
("list", Some(args)) => {
|
||||
vore.list(args)?;
|
||||
}
|
||||
|
||||
("prepare", Some(args)) => {
|
||||
vore.prepare(args)?;
|
||||
}
|
||||
|
||||
("daemon", Some(args)) => {
|
||||
match args.subcommand() {
|
||||
("version", _) => {
|
||||
vore.daemon_version()?;
|
||||
}
|
||||
|
||||
(s, _) => {
|
||||
log::error!("Subcommand daemon.{} not implemented", s);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
(s, _) => {
|
||||
log::error!("Subcommand {} not implemented", s);
|
||||
}
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
struct LoadVMOptions {
|
||||
config: String,
|
||||
cdroms: Vec<String>,
|
||||
save: bool,
|
||||
}
|
||||
|
||||
fn get_load_vm_options(args: &ArgMatches) -> anyhow::Result<LoadVMOptions> {
|
||||
let vm_config_path = args.value_of("vm-config").unwrap();
|
||||
let config = fs::read_to_string(vm_config_path)
|
||||
.with_context(|| format!("Failed to read vm config at {}", vm_config_path))?;
|
||||
|
||||
Ok(LoadVMOptions {
|
||||
config,
|
||||
cdroms: args.values_of("cdrom").map_or(vec![], |x| x.map(|x| x.to_string()).collect::<Vec<_>>()),
|
||||
save: args.is_present("save"),
|
||||
})
|
||||
}
|
||||
|
||||
struct VoreApp {
|
||||
client: Client,
|
||||
}
|
||||
|
||||
impl VoreApp {
|
||||
fn get_vm_name(&mut self, args: &ArgMatches) -> anyhow::Result<String> {
|
||||
if let Some(vm_name) = args.value_of("vm-name") {
|
||||
Ok(vm_name.to_string())
|
||||
} else {
|
||||
let mut items = self.client.list_vms()?;
|
||||
match (items.len(), items.pop()) {
|
||||
(amount, Some(x)) if amount == 1 => return Ok(x.name),
|
||||
(0, None) => anyhow::bail!("There are no VM's loaded"),
|
||||
_ => anyhow::bail!("Multiple VM's are loaded, please specify one"),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn daemon_version(&mut self) -> anyhow::Result<()> {
|
||||
let info = self.client.host_version()?;
|
||||
println!("{} ({})", info.version, info.name);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn load(&mut self, args: &ArgMatches) -> anyhow::Result<()> {
|
||||
let vm_options = get_load_vm_options(args)?;
|
||||
|
||||
let vm_info = self.client.load_vm(&vm_options.config, vm_options.save, vm_options.cdroms)?;
|
||||
log::info!("Loaded VM {}", vm_info.name);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn list(&mut self, _: &ArgMatches) -> anyhow::Result<()> {
|
||||
let items = self.client.list_vms()?;
|
||||
|
||||
for info in items {
|
||||
println!("{}\t{}", info.name, info.state)
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn prepare(&mut self, args: &ArgMatches) -> anyhow::Result<()> {
|
||||
let name = self.get_vm_name(args)?;
|
||||
self.client.prepare(name, args.values_of("cdrom").map_or(vec![], |x| x.map(|x| x.to_string()).collect::<Vec<_>>()))?;
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
@ -1,17 +1,386 @@
|
||||
use std::collections::HashMap;
|
||||
use vore_core::VirtualMachine;
|
||||
use std::os::unix::net::UnixListener;
|
||||
use std::collections::{HashMap};
|
||||
use vore_core::{VirtualMachine, InstanceConfig, GlobalConfig, GLOBAL_CONFIG_LOCATION};
|
||||
use std::os::unix::net::{UnixListener, SocketAddr, UnixStream};
|
||||
use polling::{Poller, Event};
|
||||
use std::time::Duration;
|
||||
use anyhow::Context;
|
||||
use std::{mem, io};
|
||||
use std::io::{Read, Write};
|
||||
use vore_core::rpc::{CommandCenter, Response, Command, AllRequests, AllResponses};
|
||||
use vore_core::rpc;
|
||||
use signal_hook::low_level::{signal_name};
|
||||
use signal_hook::consts::{SIGINT, SIGTERM, SIGHUP};
|
||||
use std::path::PathBuf;
|
||||
use std::str::FromStr;
|
||||
use signal_hook::iterator::{SignalsInfo, Signals, Handle};
|
||||
use std::os::unix::io::AsRawFd;
|
||||
use std::ffi::CStr;
|
||||
use std::mem::size_of;
|
||||
|
||||
struct RPCConnection {}
|
||||
#[derive(Debug)]
|
||||
struct RPCConnection {
|
||||
stream: UnixStream,
|
||||
address: SocketAddr,
|
||||
buffer: Vec<u8>,
|
||||
uid: u32,
|
||||
user: Option<String>,
|
||||
pid: i32,
|
||||
}
|
||||
|
||||
impl Write for RPCConnection {
|
||||
fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
|
||||
self.stream.write(buf)
|
||||
}
|
||||
|
||||
fn flush(&mut self) -> io::Result<()> {
|
||||
self.stream.flush()
|
||||
}
|
||||
}
|
||||
|
||||
impl Read for RPCConnection {
|
||||
fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
|
||||
self.stream.read(buf)
|
||||
}
|
||||
}
|
||||
|
||||
const NEWLINE: u8 = '\n' as u8;
|
||||
|
||||
impl RPCConnection {
|
||||
pub fn handle_input(&mut self, own_id: usize) -> Result<(bool, Vec<(usize, Command)>), anyhow::Error> {
|
||||
let mut still_open = true;
|
||||
loop {
|
||||
let mut buffer = vec![0u8; 4096];
|
||||
match self.stream.read(&mut buffer) {
|
||||
Ok(amount) if amount == 0 => {
|
||||
still_open = false;
|
||||
break;
|
||||
}
|
||||
Ok(amount) => self.buffer.extend_from_slice(&buffer[..amount]),
|
||||
Err(err) if err.kind() == io::ErrorKind::WouldBlock => break,
|
||||
Err(err) => return Err(err.into())
|
||||
};
|
||||
}
|
||||
|
||||
let mut buffer = mem::take(&mut self.buffer);
|
||||
if still_open {
|
||||
self.buffer = buffer.split_off(buffer.iter().enumerate().rev().find(|(_, x)| **x == NEWLINE).map(|(idx, _)| idx + 1).unwrap_or(buffer.len()));
|
||||
}
|
||||
|
||||
let mut commands = vec![];
|
||||
|
||||
for part in buffer.split(|x| *x == NEWLINE) {
|
||||
if part.is_empty() {
|
||||
continue;
|
||||
}
|
||||
|
||||
|
||||
let lossy = String::from_utf8_lossy(part);
|
||||
|
||||
match CommandCenter::read_command(&lossy) {
|
||||
Ok(cmd) => {
|
||||
log::debug!("Got command: {:?}", cmd);
|
||||
commands.push((own_id, cmd));
|
||||
}
|
||||
|
||||
struct DaemonState {
|
||||
Err(err) => {
|
||||
log::info!("RPC Connection produced error: {}", err)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Ok((still_open, commands))
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Eq, PartialEq, Debug)]
|
||||
enum EventTarget {
|
||||
RPCListener,
|
||||
_Machine(String),
|
||||
RPCConnection(usize),
|
||||
None,
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
pub struct Daemon {
|
||||
event_key_storage: Vec<EventTarget>,
|
||||
global_config: GlobalConfig,
|
||||
machines: HashMap<String, VirtualMachine>,
|
||||
connections: Vec<RPCConnection>,
|
||||
connections: Vec<Option<RPCConnection>>,
|
||||
rpc_listener: UnixListener,
|
||||
socket_path: PathBuf,
|
||||
poller: Poller,
|
||||
signals: SignalsInfo,
|
||||
signals_handle: Handle,
|
||||
queue: Vec<Event>,
|
||||
command_queue: Vec<(usize, Command)>,
|
||||
}
|
||||
|
||||
impl DaemonState {
|
||||
pub fn wait() {
|
||||
impl Daemon {
|
||||
pub fn new() -> Result<Daemon, anyhow::Error> {
|
||||
log::debug!("Loading global config ({})", GLOBAL_CONFIG_LOCATION);
|
||||
let toml = std::fs::read_to_string(GLOBAL_CONFIG_LOCATION)?;
|
||||
let global_config = GlobalConfig::load(&toml)?;
|
||||
log::debug!("Creating vore daemon");
|
||||
let signals = Signals::new(&[SIGINT, SIGHUP])?;
|
||||
let handle = signals.handle();
|
||||
log::debug!("Bound signal handlers");
|
||||
let poller = Poller::new().context("Failed to make poller")?;
|
||||
let socket_path = PathBuf::from_str("/run/vore.sock")?;
|
||||
let rpc_listener = UnixListener::bind(&socket_path).context("Failed to bind vore socket")?;
|
||||
rpc_listener.set_nonblocking(true)?;
|
||||
log::debug!("Bound to /run/vore.sock");
|
||||
|
||||
let mut daemon = Daemon {
|
||||
event_key_storage: vec![],
|
||||
global_config,
|
||||
machines: Default::default(),
|
||||
connections: vec![],
|
||||
rpc_listener,
|
||||
poller,
|
||||
signals,
|
||||
signals_handle: handle,
|
||||
queue: vec![],
|
||||
command_queue: vec![],
|
||||
socket_path,
|
||||
};
|
||||
|
||||
daemon.init()?;
|
||||
Ok(daemon)
|
||||
}
|
||||
|
||||
pub fn init(&mut self) -> Result<(), anyhow::Error> {
|
||||
let new_key = self.add_target(EventTarget::RPCListener);
|
||||
self.poller.add(&self.rpc_listener, Event::readable(new_key))?;
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub fn run(&mut self) -> Result<(), anyhow::Error> {
|
||||
loop {
|
||||
let res = self.wait().context("Got error while waiting for new notifications");
|
||||
match res {
|
||||
// Interrupted is uh "always" when we get a signal
|
||||
Err(err) if err.downcast_ref::<io::Error>().map(|x| x.kind() == io::ErrorKind::Interrupted).unwrap_or(false) => {
|
||||
if !self.handle_exit_code()? {
|
||||
break;
|
||||
}
|
||||
}
|
||||
err => err?
|
||||
}
|
||||
|
||||
if !self.handle_event_queue()? {
|
||||
break;
|
||||
}
|
||||
|
||||
self.handle_command_queue()?;
|
||||
}
|
||||
|
||||
// TODO: clean up
|
||||
log::info!("vore daemon has ended");
|
||||
std::fs::remove_file(&self.socket_path).context("Failed cleaning up socket")?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub fn handle_command_queue(&mut self) -> Result<(), anyhow::Error> {
|
||||
while let Some((id, command)) = self.command_queue.pop() {
|
||||
let resp = self.handle_command(&command);
|
||||
if let Err(err) = &resp {
|
||||
log::warn!("Command {:?} failed with error: {:?}", command, err)
|
||||
}
|
||||
|
||||
if let Some(conn) = self.connections[id].as_mut() {
|
||||
conn.write_all(CommandCenter::write_answer(&command, resp)?.as_bytes())?;
|
||||
}
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub fn handle_command(&mut self, command: &Command) -> Result<AllResponses, anyhow::Error> {
|
||||
let resp = match &command.data {
|
||||
AllRequests::Info(_) => {
|
||||
rpc::InfoResponse {
|
||||
name: "vore".to_string(),
|
||||
version: format!("{}.{}.{}{}",
|
||||
env!("CARGO_PKG_VERSION_MAJOR"),
|
||||
env!("CARGO_PKG_VERSION_MINOR"),
|
||||
env!("CARGO_PKG_VERSION_PATCH"),
|
||||
option_env!("CARGO_PKG_VERSION_PRE").unwrap_or("")),
|
||||
}
|
||||
.into_enum()
|
||||
}
|
||||
AllRequests::List(_) => {
|
||||
rpc::ListResponse {
|
||||
items: self.machines.values().map(|x| x.info()).collect()
|
||||
}
|
||||
.into_enum()
|
||||
}
|
||||
AllRequests::Load(val) => {
|
||||
let config = InstanceConfig::from_toml(&val.toml)?;
|
||||
let working_dir = val.working_directory.as_ref().cloned().unwrap_or_else(|| format!("/var/lib/vore/{}", config.name));
|
||||
let vm = VirtualMachine::new(config, &self.global_config, working_dir);
|
||||
let info = vm.info();
|
||||
self.mount_machine(vm);
|
||||
|
||||
rpc::LoadResponse {
|
||||
info,
|
||||
}
|
||||
.into_enum()
|
||||
}
|
||||
AllRequests::Prepare(val) => {
|
||||
if let Some(machine) = self.machines.get_mut(&val.name) {
|
||||
machine.prepare(true, false)?;
|
||||
} else {
|
||||
anyhow::bail!("No machine with the name {} exists", val.name);
|
||||
}
|
||||
|
||||
rpc::PrepareResponse {}.into_enum()
|
||||
}
|
||||
AllRequests::Start(_) => {
|
||||
anyhow::bail!("Unimplemented");
|
||||
}
|
||||
AllRequests::Stop(_) => {
|
||||
anyhow::bail!("Unimplemented");
|
||||
}
|
||||
AllRequests::Unload(_) => {
|
||||
anyhow::bail!("Unimplemented");
|
||||
}
|
||||
};
|
||||
|
||||
Ok(resp)
|
||||
}
|
||||
|
||||
pub fn handle_exit_code(&mut self) -> Result<bool, anyhow::Error> {
|
||||
for signal in self.signals.pending() {
|
||||
log::info!("Received signal {} ({})", signal_name(signal).unwrap_or("<unknown>"), signal);
|
||||
match signal {
|
||||
SIGINT | SIGTERM => return Ok(false),
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
Ok(true)
|
||||
}
|
||||
|
||||
pub fn handle_event_queue(&mut self) -> Result<bool, anyhow::Error> {
|
||||
let queue = mem::take(&mut self.queue);
|
||||
for event in queue {
|
||||
let target = self.event_key_storage.get(event.key).cloned();
|
||||
if let Some(item) = target {
|
||||
log::debug!("Handling {:?} from target {:?}", event, item);
|
||||
|
||||
match item {
|
||||
EventTarget::RPCListener => {
|
||||
self.poller.modify(&self.rpc_listener, Event::readable(event.key))?;
|
||||
self.accept_rpc_connections()?;
|
||||
}
|
||||
EventTarget::_Machine(name) if self.machines.contains_key(&name) => {
|
||||
if let Some(control_socket) = self.machines[&name].control_stream() {
|
||||
self.poller.modify(control_socket, Event::readable(event.key))?;
|
||||
}
|
||||
}
|
||||
EventTarget::RPCConnection(rpc_connection_id) if self.connections.get(rpc_connection_id).map(Option::is_some).unwrap_or(false) => {
|
||||
let (still_open, mut commands) = if let Some(rpc_connection) = &mut self.connections[rpc_connection_id] {
|
||||
let input_res = rpc_connection.handle_input(rpc_connection_id)?;
|
||||
if input_res.0 {
|
||||
self.poller.modify(&rpc_connection.stream, Event::readable(event.key))?;
|
||||
}
|
||||
|
||||
input_res
|
||||
} else {
|
||||
(false, vec![])
|
||||
};
|
||||
|
||||
if !still_open {
|
||||
log::info!("RPC connection {} closed", rpc_connection_id);
|
||||
self.connections[rpc_connection_id] = None;
|
||||
}
|
||||
|
||||
self.command_queue.append(&mut commands)
|
||||
}
|
||||
_ => continue,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Ok(true)
|
||||
}
|
||||
|
||||
fn accept_rpc_connections(&mut self) -> Result<(), anyhow::Error> {
|
||||
loop {
|
||||
let (stream, address) = match self.rpc_listener.accept() {
|
||||
Ok(value) => value,
|
||||
Err(err) if err.kind() == io::ErrorKind::WouldBlock => return Ok(()),
|
||||
Err(err) => return Err(err)?
|
||||
};
|
||||
|
||||
stream.set_nonblocking(true)?;
|
||||
|
||||
let mut user: Option<String> = None;
|
||||
let ucred = unsafe {
|
||||
let mut ucred: libc::ucred = mem::zeroed();
|
||||
let mut length = size_of::<libc::ucred>() as u32;
|
||||
libc::getsockopt(stream.as_raw_fd(), libc::SOL_SOCKET, libc::SO_PEERCRED, (&mut ucred) as *mut _ as _, &mut length);
|
||||
let passwd = libc::getpwuid(ucred.uid);
|
||||
if !passwd.is_null() {
|
||||
user = CStr::from_ptr((*passwd).pw_name).to_str().ok().map(|x| x.to_string())
|
||||
}
|
||||
|
||||
ucred
|
||||
};
|
||||
|
||||
let conn = RPCConnection {
|
||||
stream,
|
||||
address,
|
||||
buffer: vec![],
|
||||
uid: ucred.uid,
|
||||
user,
|
||||
pid: ucred.pid,
|
||||
};
|
||||
|
||||
log::info!(
|
||||
"Got new RPC connection from {} (pid: {}, socket: {:?})",
|
||||
conn.user.as_ref().map_or_else(|| format!("uid:{}", conn.uid), |x| format!("{} ({})", x, conn.uid)),
|
||||
conn.pid,
|
||||
conn.address,
|
||||
);
|
||||
|
||||
let id = self.add_rpc_connection(conn);
|
||||
let event_target = self.add_target(EventTarget::RPCConnection(id));
|
||||
self.poller.add(&self.connections[id].as_ref().unwrap().stream, Event::readable(event_target))?;
|
||||
}
|
||||
}
|
||||
|
||||
pub fn wait(&mut self) -> Result<(), anyhow::Error> {
|
||||
self.poller.wait(&mut self.queue, Some(Duration::from_secs(5)))?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn add_target(&mut self, event_target: EventTarget) -> usize {
|
||||
let id = self.event_key_storage.iter().enumerate().find(|(_, target)| target.eq(&&EventTarget::None));
|
||||
if let Some((id, _)) = id {
|
||||
self.event_key_storage[id] = event_target;
|
||||
return id;
|
||||
}
|
||||
|
||||
let new_id = self.event_key_storage.len();
|
||||
self.event_key_storage.push(event_target);
|
||||
return new_id;
|
||||
}
|
||||
|
||||
fn add_rpc_connection(&mut self, rpc_connection: RPCConnection) -> usize {
|
||||
let id = self.connections.iter().enumerate().find(|(_, target)| target.is_none());
|
||||
if let Some((id, _)) = id {
|
||||
self.connections[id] = Some(rpc_connection);
|
||||
return id;
|
||||
}
|
||||
|
||||
let new_id = self.connections.len();
|
||||
self.connections.push(Some(rpc_connection));
|
||||
return new_id;
|
||||
}
|
||||
|
||||
fn mount_machine(&mut self, vm: VirtualMachine) {
|
||||
let name = vm.name().to_string();
|
||||
self.machines.insert(name.clone(), vm);
|
||||
}
|
||||
}
|
||||
@ -1,14 +1,11 @@
|
||||
mod daemon;
|
||||
use crate::daemon::Daemon;
|
||||
use vore_core::init_logging;
|
||||
|
||||
use std::path::PathBuf;
|
||||
use vore_core::{GlobalConfig, InstanceConfig, VirtualMachine};
|
||||
mod daemon;
|
||||
|
||||
fn main() {
|
||||
let cfg = InstanceConfig::from_toml(include_str!("../../config/example.toml")).unwrap();
|
||||
let global = GlobalConfig::load(include_str!("../../config/global.toml")).unwrap();
|
||||
let mut vm = VirtualMachine::new(cfg, &global, PathBuf::from("/home/eater/.local/vore/win10"));
|
||||
vm.prepare(true, false).unwrap();
|
||||
vm.start().unwrap();
|
||||
vm.wait_till_stopped().unwrap();
|
||||
vm.stop_now().unwrap()
|
||||
init_logging();
|
||||
|
||||
let mut daemon = Daemon::new().unwrap();
|
||||
daemon.run().unwrap();
|
||||
}
|
||||
|
||||
Loading…
Reference in New Issue