Start9/start-os
2
0
Fork 0
mirror of https://github.com/Start9Labs/start-os.git synced 2026-03-26 02:11:53 +00:00
Code Issues Packages Projects Releases Wiki Activity

formatting (#1698)

Browse Source
This commit is contained in:
Aiden McClelland
2022-07-27 18:00:48 -06:00
committed by GitHub
parent d5f7e15dfb
commit 13b97296f5
27 changed files with 149 additions and 132 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
Makefile
View File

@@ -33,6 +33,10 @@ clean:
rm -rf patch-db/client/dist
sudo rm -rf cargo-deps
format:
cd backend && cargo +nightly fmt
cd libs && cargo +nightly fmt
sdk:
cd backend/ && ./install-sdk.sh

3
backend/src/action.rs
View File

@@ -3,6 +3,7 @@ use std::collections::{BTreeMap, BTreeSet};
use clap::ArgMatches;
use color_eyre::eyre::eyre;
use indexmap::IndexSet;
pub use models::ActionId;
use rpc_toolkit::command;
use serde::{Deserialize, Serialize};
use tracing::instrument;
@@ -16,8 +17,6 @@ use crate::util::serde::{display_serializable, parse_stdin_deserializable, IoFor
use crate::util::Version;
use crate::volume::Volumes;
use crate::{Error, ResultExt};
pub use models::ActionId;
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct Actions(pub BTreeMap<ActionId, Action>);

51
backend/src/backup/restore.rs
View File

@@ -55,11 +55,8 @@ pub async fn restore_packages_rpc(
let fs = target_id
.load(&mut ctx.secret_store.acquire().await?)
.await?;
let backup_guard = BackupMountGuard::mount(
TmpMountGuard::mount(&fs, ReadOnly).await?,
&password,
)
.await?;
let backup_guard =
BackupMountGuard::mount(TmpMountGuard::mount(&fs, ReadOnly).await?, &password).await?;
let (revision, backup_guard, tasks, _) =
restore_packages(&ctx, &mut db, backup_guard, ids).await?;
@@ -70,31 +67,45 @@ pub async fn restore_packages_rpc(
match res.with_kind(crate::ErrorKind::Unknown) {
Ok((Ok(_), _)) => (),
Ok((Err(err), package_id)) => {
if let Err(err) = ctx.notification_manager.notify(
&mut db,
Some(package_id.clone()),
NotificationLevel::Error,
"Restoration Failure".to_string(), format!("Error restoring package {}: {}", package_id,err), (), None).await{
if let Err(err) = ctx
.notification_manager
.notify(
&mut db,
Some(package_id.clone()),
NotificationLevel::Error,
"Restoration Failure".to_string(),
format!("Error restoring package {}: {}", package_id, err),
(),
None,
)
.await
{
tracing::error!("Failed to notify: {}", err);
tracing::debug!("{:?}", err);
};
};
tracing::error!("Error restoring package {}: {}", package_id, err);
tracing::debug!("{:?}", err);
},
}
Err(e) => {
if let Err(err) = ctx.notification_manager.notify(
&mut db,
None,
NotificationLevel::Error,
"Restoration Failure".to_string(), format!("Error during restoration: {}", e), (), None).await {
if let Err(err) = ctx
.notification_manager
.notify(
&mut db,
None,
NotificationLevel::Error,
"Restoration Failure".to_string(),
format!("Error during restoration: {}", e),
(),
None,
)
.await
{
tracing::error!("Failed to notify: {}", err);
tracing::debug!("{:?}", err);
}
tracing::error!("Error restoring packages: {}", e);
tracing::debug!("{:?}", e);
},
}
}
}
if let Err(e) = backup_guard.unmount().await {

5
backend/src/id.rs
View File

@@ -1,14 +1,11 @@
use std::fmt::Debug;
use std::str::FromStr;
pub use models::{Id, IdUnchecked, InvalidId, SYSTEM_ID};
use serde::{Deserialize, Deserializer, Serialize};
use crate::util::Version;
pub use models::{Id, InvalidId, IdUnchecked, SYSTEM_ID};
#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize)]
pub struct ImageId<S: AsRef<str> = String>(Id<S>);
impl<S: AsRef<str>> std::fmt::Display for ImageId<S> {

3
backend/src/migration.rs
View File

@@ -10,8 +10,7 @@ use tracing::instrument;
use crate::context::RpcContext;
use crate::id::ImageId;
use crate::procedure::PackageProcedure;
use crate::procedure::ProcedureName;
use crate::procedure::{PackageProcedure, ProcedureName};
use crate::s9pk::manifest::PackageId;
use crate::util::Version;
use crate::volume::Volumes;

4
backend/src/net/interface.rs
View File

@@ -4,6 +4,7 @@ use color_eyre::eyre::eyre;
use futures::TryStreamExt;
use indexmap::IndexSet;
use itertools::Either;
pub use models::InterfaceId;
use serde::{Deserialize, Deserializer, Serialize};
use sqlx::{Executor, Sqlite};
use torut::onion::TorSecretKeyV3;
@@ -15,8 +16,6 @@ use crate::s9pk::manifest::PackageId;
use crate::util::serde::Port;
use crate::{Error, ResultExt};
pub use models::InterfaceId;
#[derive(Clone, Debug, Deserialize, Serialize)]
#[serde(rename_all = "kebab-case")]
pub struct Interfaces(pub BTreeMap<InterfaceId, Interface>); // TODO
@@ -114,7 +113,6 @@ impl Interfaces {
}
}
#[derive(Clone, Debug, Deserialize, Serialize)]
#[serde(rename_all = "kebab-case")]
pub struct Interface {

67
backend/src/net/nginx.rs
View File

@@ -91,35 +91,44 @@ impl NginxControllerInner {
for (id, meta) in interface_map.iter() {
for (port, lan_port_config) in meta.lan_config.iter() {
// get ssl certificate chain
let (listen_args, ssl_certificate_line, ssl_certificate_key_line, proxy_redirect_directive) =
if lan_port_config.ssl {
// these have already been written by the net controller
let package_path = nginx_root.join(format!("ssl/{}", package));
if tokio::fs::metadata(&package_path).await.is_err() {
tokio::fs::create_dir_all(&package_path)
.await
.with_ctx(|_| {
(ErrorKind::Filesystem, package_path.display().to_string())
})?;
}
let ssl_path_key = package_path.join(format!("{}.key.pem", id));
let ssl_path_cert = package_path.join(format!("{}.cert.pem", id));
let (key, chain) = ssl_manager
.certificate_for(&meta.dns_base, &package)
.await?;
tokio::try_join!(
crate::net::ssl::export_key(&key, &ssl_path_key),
crate::net::ssl::export_cert(&chain, &ssl_path_cert)
)?;
(
format!("{} ssl", port.0),
format!("ssl_certificate {};", ssl_path_cert.to_str().unwrap()),
format!("ssl_certificate_key {};", ssl_path_key.to_str().unwrap()),
format!("proxy_redirect http://$host/ https://$host/;"),
)
} else {
(format!("{}", port.0), String::from(""), String::from(""), String::from(""))
};
let (
listen_args,
ssl_certificate_line,
ssl_certificate_key_line,
proxy_redirect_directive,
) = if lan_port_config.ssl {
// these have already been written by the net controller
let package_path = nginx_root.join(format!("ssl/{}", package));
if tokio::fs::metadata(&package_path).await.is_err() {
tokio::fs::create_dir_all(&package_path)
.await
.with_ctx(|_| {
(ErrorKind::Filesystem, package_path.display().to_string())
})?;
}
let ssl_path_key = package_path.join(format!("{}.key.pem", id));
let ssl_path_cert = package_path.join(format!("{}.cert.pem", id));
let (key, chain) = ssl_manager
.certificate_for(&meta.dns_base, &package)
.await?;
tokio::try_join!(
crate::net::ssl::export_key(&key, &ssl_path_key),
crate::net::ssl::export_cert(&chain, &ssl_path_cert)
)?;
(
format!("{} ssl", port.0),
format!("ssl_certificate {};", ssl_path_cert.to_str().unwrap()),
format!("ssl_certificate_key {};", ssl_path_key.to_str().unwrap()),
format!("proxy_redirect http://$host/ https://$host/;"),
)
} else {
(
format!("{}", port.0),
String::from(""),
String::from(""),
String::from(""),
)
};
// write nginx configs
let nginx_conf_path = nginx_root.join(format!(
"sites-available/{}_{}_{}.conf",

21
backend/src/procedure/js_scripts.rs
View File

@@ -1,21 +1,18 @@
use std::{
path::{Path, PathBuf},
time::Duration,
};
use std::path::{Path, PathBuf};
use std::time::Duration;
pub use js_engine::JsError;
use js_engine::{JsExecutionEnvironment, PathForVolumeId};
use models::VolumeId;
use serde::{Deserialize, Serialize};
use tracing::instrument;
use crate::{
context::RpcContext, s9pk::manifest::PackageId, util::Version, volume::Volumes, Error,
};
use js_engine::{JsExecutionEnvironment, PathForVolumeId};
use super::ProcedureName;
pub use js_engine::JsError;
use crate::context::RpcContext;
use crate::s9pk::manifest::PackageId;
use crate::util::Version;
use crate::volume::Volumes;
use crate::Error;
#[derive(Debug, Serialize, Deserialize, Clone)]
#[serde(rename_all = "kebab-case")]

3
backend/src/s9pk/manifest.rs
View File

@@ -1,6 +1,7 @@
use std::path::{Path, PathBuf};
use color_eyre::eyre::eyre;
pub use models::{PackageId, SYSTEM_PACKAGE_ID};
use patch_db::HasModel;
use serde::{Deserialize, Serialize};
use url::Url;
@@ -18,8 +19,6 @@ use crate::version::{Current, VersionT};
use crate::volume::Volumes;
use crate::Error;
pub use models::{PackageId, SYSTEM_PACKAGE_ID};
fn current_version() -> Version {
Current::new().semver().into()
}

3
backend/src/status/health_check.rs
View File

@@ -1,6 +1,7 @@
use std::collections::{BTreeMap, BTreeSet};
use chrono::{DateTime, Utc};
pub use models::HealthCheckId;
use serde::{Deserialize, Serialize};
use tracing::instrument;
@@ -13,8 +14,6 @@ use crate::util::Version;
use crate::volume::Volumes;
use crate::{Error, ResultExt};
pub use models::HealthCheckId;
#[derive(Clone, Debug, Deserialize, Serialize)]
pub struct HealthChecks(pub BTreeMap<HealthCheckId, HealthCheck>);
impl HealthChecks {

6
backend/src/version/mod.rs
View File

@@ -5,7 +5,8 @@ use color_eyre::eyre::eyre;
use patch_db::DbHandle;
use rpc_toolkit::command;
use crate::{init::InitReceipts, Error};
use crate::init::InitReceipts;
use crate::Error;
mod v0_3_0;
mod v0_3_0_1;
@@ -198,9 +199,10 @@ pub fn git_info() -> Result<&'static str, Error> {
#[cfg(test)]
mod tests {
use super::*;
use proptest::prelude::*;
use super::*;
fn em_version() -> impl Strategy<Value = emver::Version> {
any::<(usize, usize, usize, usize)>().prop_map(|(major, minor, patch, super_minor)| {
emver::Version::new(major, minor, patch, super_minor)

3
backend/src/version/v0_3_1.rs
View File

@@ -1,6 +1,7 @@
use emver::VersionRange;
use super::{v0_3_0::V0_3_0_COMPAT, *};
use super::v0_3_0::V0_3_0_COMPAT;
use super::*;
const V0_3_1: emver::Version = emver::Version::new(0, 3, 1, 0);

3
backend/src/version/v0_3_1_1.rs
View File

@@ -1,6 +1,7 @@
use emver::VersionRange;
use super::{v0_3_0::V0_3_0_COMPAT, *};
use super::v0_3_0::V0_3_0_COMPAT;
use super::*;
const V0_3_1_1: emver::Version = emver::Version::new(0, 3, 1, 1);

5
backend/src/volume.rs
View File

@@ -2,6 +2,8 @@ use std::collections::BTreeMap;
use std::ops::{Deref, DerefMut};
use std::path::{Path, PathBuf};
pub use helpers::script_dir;
pub use models::VolumeId;
use patch_db::{HasModel, Map, MapModel};
use serde::{Deserialize, Serialize};
use tracing::instrument;
@@ -13,9 +15,6 @@ use crate::s9pk::manifest::PackageId;
use crate::util::Version;
use crate::{Error, ResultExt};
pub use helpers::script_dir;
pub use models::VolumeId;
pub const PKG_VOLUME_DIR: &str = "package-data/volumes";
pub const BACKUP_DIR: &str = "/media/embassy-os/backups";

6
libs/js_engine/src/lib.rs
View File

@@ -338,11 +338,12 @@ impl JsExecutionEnvironment {
/// Note: Make sure that we have the assumption that all these methods are callable at any time, and all call restrictions should be in rust
mod fns {
use std::cell::RefCell;
use std::collections::BTreeMap;
use std::convert::TryFrom;
use std::os::unix::fs::MetadataExt;
use std::path::{Path, PathBuf};
use std::rc::Rc;
use std::{cell::RefCell, collections::BTreeMap};
use deno_core::anyhow::{anyhow, bail};
use deno_core::error::AnyError;
@@ -530,8 +531,9 @@ mod fns {
}
let new_volume_tmp = to_tmp_path(&volume_path).map_err(|e| anyhow!("{}", e))?;
let hashed_name = {
use sha2::{Digest, Sha256};
use std::os::unix::ffi::OsStrExt;
use sha2::{Digest, Sha256};
let mut hasher = Sha256::new();
hasher.update(path_in.as_os_str().as_bytes());

6
libs/models/src/action_id.rs
View File

@@ -1,10 +1,10 @@
use std::{str::FromStr, path::Path};
use std::path::Path;
use std::str::FromStr;
use serde::{Serialize, Deserialize};
use serde::{Deserialize, Serialize};
use crate::{Id, InvalidId};
#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize)]
pub struct ActionId<S: AsRef<str> = String>(Id<S>);
impl FromStr for ActionId {

2
libs/models/src/health_check_id.rs
View File

@@ -1,6 +1,6 @@
use std::path::Path;
use serde::{Serialize, Deserialize, Deserializer};
use serde::{Deserialize, Deserializer, Serialize};
use crate::Id;

3
libs/models/src/id.rs
View File

@@ -2,7 +2,8 @@ use std::borrow::Borrow;
use serde::{Deserialize, Deserializer, Serialize, Serializer};
use crate::{invalid_id::InvalidId, id_unchecked::IdUnchecked};
use crate::id_unchecked::IdUnchecked;
use crate::invalid_id::InvalidId;
pub const SYSTEM_ID: Id<&'static str> = Id("x_system");

1
libs/models/src/id_unchecked.rs
View File

@@ -2,7 +2,6 @@ use std::borrow::Cow;
use serde::{Deserialize, Deserializer};
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub struct IdUnchecked<S: AsRef<str>>(pub S);
impl<'de> Deserialize<'de> for IdUnchecked<Cow<'de, str>> {

3
libs/models/src/interface_id.rs
View File

@@ -1,10 +1,9 @@
use std::path::Path;
use serde::{Serialize, Deserialize, Deserializer};
use serde::{Deserialize, Deserializer, Serialize};
use crate::Id;
#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize)]
pub struct InterfaceId<S: AsRef<str> = String>(Id<S>);
impl<S: AsRef<str>> From<Id<S>> for InterfaceId<S> {

1
libs/models/src/invalid_id.rs
View File

@@ -1,4 +1,3 @@
#[derive(Debug, thiserror::Error)]
#[error("Invalid ID")]
pub struct InvalidId;

40
libs/models/src/lib.rs
View File

@@ -1,21 +1,21 @@
mod id;
mod invalid_id;
mod id_unchecked;
mod version;
mod volume_id;
mod interface_id;
mod package_id;
mod procedure_name;
mod health_check_id;
mod action_id;
mod action_id;
mod health_check_id;
mod id;
mod id_unchecked;
mod interface_id;
mod invalid_id;
mod package_id;
mod procedure_name;
mod version;
mod volume_id;
pub use id::*;
pub use invalid_id::*;
pub use id_unchecked::*;
pub use version::*;
pub use volume_id::*;
pub use interface_id::*;
pub use package_id::*;
pub use procedure_name::*;
pub use health_check_id::*;
pub use action_id::*;
pub use action_id::*;
pub use health_check_id::*;
pub use id::*;
pub use id_unchecked::*;
pub use interface_id::*;
pub use invalid_id::*;
pub use package_id::*;
pub use procedure_name::*;
pub use version::*;
pub use volume_id::*;

5
libs/models/src/package_id.rs
View File

@@ -1,10 +1,11 @@
use std::{str::FromStr, borrow::Borrow, path::Path};
use std::borrow::Borrow;
use std::path::Path;
use std::str::FromStr;
use serde::{Deserialize, Serialize, Serializer};
use crate::{Id, InvalidId, SYSTEM_ID};
pub const SYSTEM_PACKAGE_ID: PackageId<&'static str> = PackageId(SYSTEM_ID);
#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct PackageId<S: AsRef<str> = String>(Id<S>);

3
libs/models/src/procedure_name.rs
View File

@@ -1,5 +1,4 @@
use crate::{PackageId, HealthCheckId, ActionId};
use crate::{ActionId, HealthCheckId, PackageId};
#[derive(Debug, Clone)]
pub enum ProcedureName {

4
libs/models/src/version.rs
View File

@@ -1,10 +1,10 @@
use std::{str::FromStr, ops::Deref};
use std::hash::{Hash, Hasher};
use std::ops::Deref;
use std::str::FromStr;
use patch_db::{HasModel, Model};
use serde::{Deserialize, Deserializer, Serialize, Serializer};
#[derive(Debug, Clone)]
pub struct Version {
version: emver::Version,

6
libs/models/src/volume_id.rs
View File

@@ -1,10 +1,10 @@
use std::{borrow::Borrow, path::Path};
use std::borrow::Borrow;
use std::path::Path;
use serde::{Deserialize, Serialize, Deserializer};
use serde::{Deserialize, Deserializer, Serialize};
use crate::{Id, IdUnchecked};
#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum VolumeId<S: AsRef<str> = String> {
Backup,

2
libs/rustfmt.toml Normal file
View File

@@ -0,0 +1,2 @@
group_imports = "StdExternalCrate"
imports_granularity = "Module"