#![cfg_attr(target_family = "wasm", allow(dead_code))]
use crate::services::{
brotli_svc::brotli_impl, dyn_ld, http_server, packages, producers, setcode, sites, transact,
x_sites,
};
use crate::{
deserialize_pretty_action, new_account_owned_action, preapprove_action, reg_server,
schema_types, set_code_action, solve_dependencies, version_match, AccountNumber, Action,
AnyPublicKey, Checksum256, CodeRow, CustomPrettyAction, GenesisService, Hex, MethodNumber,
MethodString, NullSchemaFetcher, PackageDisposition, PackageOp, PackagePreference, Schema,
SchemaFetcher, ServiceWrapper, ToSchema, TypeMatchExt, Version,
};
use anyhow::{anyhow, Context};
use async_trait::async_trait;
use custom_error::custom_error;
use flate2::write::GzEncoder;
use fracpack::{
CompiledSchema, CompiledType, CustomHandler, FracInputStream, Pack, Unpack, UnpackOwned,
};
use regex::Regex;
use serde::{de::DeserializeOwned, Deserialize, Serialize};
use sha2::{Digest, Sha256};
use std::cell::RefCell;
use std::collections::{hash_map, HashMap, HashSet};
use std::ffi::OsString;
use std::fs::File;
use std::io::{BufReader, Read, Seek};
use std::path::{Path, PathBuf};
use std::str::FromStr;
use zip::ZipArchive;
#[cfg(not(target_family = "wasm"))]
use crate::services::{x_admin, x_http, x_packages};
#[cfg(not(target_family = "wasm"))]
use crate::ChainUrl;
#[cfg(not(target_family = "wasm"))]
use std::io::Write;
#[cfg(not(target_family = "wasm"))]
use tempfile::tempfile;
custom_error! {
pub Error
MissingMeta = "Service does not contain meta.json",
InvalidFlags = "Invalid service flags",
DependencyCycle{package: String} = "Cycle in install dependencies for {package}",
UnknownFileType{path:String} = "Cannot determine Mime-Type for {path}",
UnknownAccount{name:AccountNumber} = "Account {name} not defined in meta.json",
ServiceConflict{name: AccountNumber, old: String, new: String} = "The service {name} is defined by more than one package: {old}, {new}",
FileConflict{name: AccountNumber, filename: String, old: String, new: String} = "The file {name}:{filename} is defined by more than one package: {old}, {new}",
MissingDepAccount{name: AccountNumber, package: String} = "The account {name} required by {package} is not defined by any package",
MissingDepPackage{name: String, dep: String} = "The package {name} uses {dep} but does not depend on it",
PackageNotFound{package: String} = "The package {package} was not found",
DuplicatePackage{package: String} = "The package {package} was declared multiple times in the package index",
PackageDigestFailure{package: String} = "The package file for {package} does not match the package index",
PackageMetaMismatch{package: String} = "The package metadata for {package} does not match the package index",
CrossOriginFile{file: String} = "The package file {file} has a different origin from the package index",
UnknownAction{service: AccountNumber, method: MethodNumber} = "{service} does not have an action called {method}",
MissingSchema{service: AccountNumber} = "Cannot find schema for {service}",
InvalidPackageSource = "Invalid package source",
InvalidVerifyService = "Invalid verify service",
}
fn should_compress(content_type: &str) -> bool {
matches!(
content_type,
"text/plain"
| "text/html"
| "text/css"
| "application/javascript"
| "application/json"
| "application/xml"
| "application/rss+xml"
| "application/atom+xml"
| "image/svg+xml"
| "font/ttf"
| "font/otf"
| "application/wasm"
)
}
pub fn compress_content(
content: &[u8],
content_type: &str,
compression_level: u32,
) -> (Vec<u8>, Option<String>) {
if should_compress(content_type) {
assert!(
compression_level >= 1 && compression_level <= 11,
"Compression level must be between 1 and 11"
);
let compressed_content = brotli_impl::compress(content.to_vec(), compression_level as u8);
(compressed_content, Some("br".to_string()))
} else {
(content.to_vec(), None)
}
}
#[derive(
Debug, Clone, Default, Serialize, Deserialize, PartialEq, Eq, Pack, Unpack, ToSchema, Hash,
)]
#[fracpack(fracpack_mod = "fracpack")]
pub struct PackageRef {
pub name: String,
pub version: String,
}
#[derive(
Debug, Clone, Default, Serialize, Deserialize, PartialEq, Eq, Pack, Unpack, ToSchema, Hash,
)]
#[fracpack(fracpack_mod = "fracpack")]
pub struct PackageExport {
pub name: String,
pub service: AccountNumber,
}
fn network_scope() -> String {
"network".to_string()
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq, Eq, Pack, Unpack, ToSchema)]
#[fracpack(fracpack_mod = "fracpack")]
pub struct Meta {
pub name: String,
pub version: String,
#[serde(default = "network_scope")]
pub scope: String,
#[serde(default)]
pub description: String,
#[serde(default)]
pub depends: Vec<PackageRef>,
#[serde(default)]
pub accounts: Vec<AccountNumber>,
#[serde(default)]
pub services: Vec<AccountNumber>,
pub exports: Vec<PackageExport>,
}
impl Meta {
pub fn info(&self, sha256: Checksum256, file: String) -> PackageInfo {
return PackageInfo {
name: self.name.clone(),
version: self.version.clone(),
scope: self.scope.clone(),
description: self.description.clone(),
depends: self.depends.clone(),
accounts: self.accounts.clone(),
services: self.services.clone(),
exports: self.exports.clone(),
sha256,
file,
};
}
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq, Eq)]
pub struct PackageInfo {
pub name: String,
pub version: String,
#[serde(default = "network_scope")]
pub scope: String,
#[serde(default)]
pub description: String,
#[serde(default)]
pub depends: Vec<PackageRef>,
#[serde(default)]
pub accounts: Vec<AccountNumber>,
#[serde(default)]
pub services: Vec<AccountNumber>,
#[serde(default)]
pub exports: Vec<PackageExport>,
#[serde(default)]
pub sha256: Checksum256,
#[serde(default)]
pub file: String,
}
impl PackageInfo {
fn meta(&self) -> Meta {
Meta {
name: self.name.clone(),
version: self.version.clone(),
scope: self.scope.clone(),
description: self.description.clone(),
depends: self.depends.clone(),
accounts: self.accounts.clone(),
services: self.services.clone(),
exports: self.exports.clone(),
}
}
pub fn is_local(&self) -> Option<bool> {
match self.scope.as_str() {
"local" => Some(true),
"network" => Some(false),
_ => None,
}
}
}
pub type InstalledPackageInfo = packages::InstalledPackage;
impl InstalledPackageInfo {
pub fn meta(&self) -> Meta {
Meta {
name: self.name.clone(),
version: self.version.clone(),
scope: "network".to_string(),
description: self.description.clone(),
depends: self.depends.clone(),
accounts: self.accounts.clone(),
services: self.services.clone(),
exports: self.exports.clone(),
}
}
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq, Eq)]
pub struct LocalPackageInfo {
pub name: String,
pub version: String,
pub description: String,
pub depends: Vec<PackageRef>,
pub accounts: Vec<AccountNumber>,
pub services: Vec<AccountNumber>,
pub exports: Vec<PackageExport>,
pub sha256: Checksum256,
}
impl LocalPackageInfo {
pub fn meta(&self) -> Meta {
Meta {
name: self.name.clone(),
version: self.version.clone(),
scope: "local".to_string(),
description: self.description.clone(),
depends: self.depends.clone(),
accounts: self.accounts.clone(),
services: self.services.clone(),
exports: self.exports.clone(),
}
}
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq, Eq, Hash)]
pub struct PackageDataFile {
pub account: AccountNumber,
pub filename: String,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct PackageManifest {
pub services: HashMap<AccountNumber, ServiceInfo>,
pub data: Vec<PackageDataFile>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq, Eq)]
pub struct ServiceInfo {
pub flags: Vec<String>,
pub server: Option<AccountNumber>,
pub schema: Option<Schema>,
}
impl ServiceInfo {
pub fn parse_flags(&self) -> u64 {
translate_flags(&self.flags).unwrap()
}
}
pub struct PackagedService<R: Read + Seek> {
archive: zip::read::ZipArchive<R>,
meta: Meta,
services: Vec<(AccountNumber, usize, ServiceInfo)>,
data: Vec<(AccountNumber, usize)>,
postinstall: Vec<PrettyAction>,
hash: Checksum256,
}
pub type SchemaMap = HashMap<AccountNumber, Schema>;
#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq, Eq)]
#[serde(rename_all = "camelCase")]
pub struct PrettyAction {
pub sender: AccountNumber,
pub service: String,
pub method: MethodNumber,
pub raw_data: Option<Hex<Vec<u8>>>,
pub data: Option<serde_json::Value>,
}
impl PrettyAction {
fn pack_data(
service: AccountNumber,
method: MethodNumber,
data: &Option<serde_json::Value>,
schemas: &SchemaMap,
) -> Result<Hex<Vec<u8>>, anyhow::Error> {
let schema = schemas.get(&service).unwrap();
let mut custom = schema_types();
let custom_action = CustomPrettyAction::new(schemas);
custom.insert("Action".to_string(), &custom_action);
let mut cschema = CompiledSchema::new(&schema.types, &custom);
let Some(act) = schema.actions.get(&MethodString(method.to_string())) else {
Err(Error::UnknownAction {
service: service,
method: method,
})?
};
cschema.extend(&act.params);
if let Some(data) = data {
Ok(cschema.from_value(&act.params, data)?.into())
} else {
Ok(cschema
.from_value(&act.params, &serde_json::json!({}))?
.into())
}
}
pub fn into_action(self, schemas: &SchemaMap) -> Result<Action, anyhow::Error> {
let service = AccountNumber::from_exact(&self.service)?;
let raw_data = if let Some(raw_data) = self.raw_data {
raw_data
} else {
PrettyAction::pack_data(service, self.method, &self.data, schemas)?
};
Ok(Action {
sender: self.sender,
service,
method: self.method,
rawData: raw_data,
})
}
pub fn to_action(&self, schemas: &SchemaMap) -> Result<Action, anyhow::Error> {
let service = AccountNumber::from_exact(&self.service)?;
let raw_data = if let Some(raw_data) = &self.raw_data {
raw_data.clone()
} else {
PrettyAction::pack_data(service, self.method, &self.data, schemas)?
};
Ok(Action {
sender: self.sender,
service: service,
method: self.method,
rawData: raw_data,
})
}
pub fn parse_data_as<T: UnpackOwned + DeserializeOwned>(&self) -> Result<T, anyhow::Error> {
if let Some(raw_data) = &self.raw_data {
Ok(T::unpacked(&raw_data.0)?)
} else if let Some(data) = &self.data {
Ok(serde_json::from_value(data.clone())?)
} else {
Err(anyhow!("Missing action data"))
}
}
pub async fn load_schemas<F: SchemaFetcher>(
&self,
fetcher: &F,
schemas: &mut SchemaMap,
) -> Result<(), anyhow::Error> {
if !self.raw_data.is_some() {
if let Some(data) = &self.data {
SharedPrettyAction {
sender: self.sender,
service: self.service.parse()?,
method: self.method,
data: data,
}
.load_schemas(fetcher, schemas)
.await?;
}
}
Ok(())
}
pub fn get_required_accounts(
&self,
accounts: &mut Vec<AccountNumber>,
services: &mut Vec<AccountNumber>,
schemas: &SchemaMap,
) -> Result<(), anyhow::Error> {
let service = self.service.parse()?;
accounts.push(self.sender);
services.push(service);
if let Some(data) = &self.data {
let schema = schemas
.get(&service)
.ok_or_else(|| anyhow!("Missing schema for {}", self.service))?;
let mut custom = schema_types();
let out = RefCell::new((accounts, services));
let custom_action = CustomPrettyActionCollectAccounts::new(
|sender, service| {
let mut out = out.borrow_mut();
let (accounts, services) = &mut *out;
if sender != AccountNumber::new(0) {
accounts.push(sender);
}
services.push(service);
},
schemas,
);
custom.insert("Action".to_string(), &custom_action);
let action_type = schema
.actions
.get(&MethodString(self.method.to_string()))
.ok_or_else(|| anyhow!("Missing action {}::{}", self.service, self.method))?;
let mut cschema = CompiledSchema::new(&schema.types, &custom);
cschema.extend(&action_type.params);
cschema.from_value(&action_type.params, data)?;
}
Ok(())
}
}
#[derive(Debug, Copy, Clone)]
struct SharedPrettyAction<'a> {
pub sender: AccountNumber,
pub service: AccountNumber,
pub method: MethodNumber,
pub data: &'a serde_json::Value,
}
impl<'a> SharedPrettyAction<'a> {
pub async fn load_schemas<F: SchemaFetcher>(
&self,
fetcher: &F,
schemas: &mut SchemaMap,
) -> Result<(), anyhow::Error> {
let mut actions = vec![self.clone()];
while let Some(next) = actions.pop() {
if !schemas.contains_key(&next.service) {
schemas.insert(next.service, fetcher.fetch_schema(next.service).await?);
}
let schema = schemas.get(&next.service).unwrap();
let mut custom = schema_types();
let actions = std::cell::RefCell::new(&mut actions);
let custom_action = CustomPrettyActionCollectSchemas::new(|act: SharedPrettyAction| {
actions.borrow_mut().push(SharedPrettyAction {
sender: act.sender,
service: act.service,
method: act.method,
data: unsafe { &*(act.data as *const serde_json::Value) },
})
});
custom.insert("Action".to_string(), &custom_action);
let action_type = schema
.actions
.get(&MethodString(next.method.to_string()))
.ok_or_else(|| anyhow!("Missing action {}::{}", next.service, next.method))?;
let mut cschema = CompiledSchema::new(&schema.types, &custom);
cschema.extend(&action_type.params);
cschema.from_value(&action_type.params, next.data)?;
}
Ok(())
}
}
struct CustomPrettyActionCollectSchemas<F> {
f: F,
}
impl<F> CustomPrettyActionCollectSchemas<F> {
fn new(f: F) -> Self {
Self { f }
}
}
impl<F: Fn(SharedPrettyAction) -> ()> CustomHandler for CustomPrettyActionCollectSchemas<F> {
fn matches(&self, schema: &CompiledSchema, ty: &CompiledType) -> bool {
schema.matches_action(ty)
}
fn frac2json(
&self,
_schema: &CompiledSchema,
_ty: &CompiledType,
_src: &mut FracInputStream,
_allow_empty_container: bool,
) -> Result<serde_json::Value, fracpack::Error> {
unimplemented!()
}
fn json2frac(
&self,
_schema: &CompiledSchema,
ty: &CompiledType,
val: &serde_json::Value,
dest: &mut Vec<u8>,
) -> Result<(), serde_json::Error> {
let (sender, service, method, _raw_data_name) = deserialize_pretty_action(ty, val)?;
if let Some(data) = val.get("data") {
(self.f)(SharedPrettyAction {
sender,
service,
method,
data,
});
}
Action {
sender,
service,
method,
rawData: Vec::<u8>::new().into(),
}
.pack(dest);
Ok(())
}
fn fracpack_verify(
&self,
_schema: &CompiledSchema,
_ty: &CompiledType,
_src: &mut FracInputStream,
_allow_empty_container: bool,
) -> Result<(), fracpack::Error> {
unimplemented!()
}
fn is_empty_container(&self, _ty: &CompiledType, _value: &serde_json::Value) -> bool {
false
}
}
struct CustomPrettyActionCollectAccounts<'a, F> {
f: F,
schemas: &'a SchemaMap,
}
impl<'a, F> CustomPrettyActionCollectAccounts<'a, F> {
fn new(f: F, schemas: &'a SchemaMap) -> Self {
Self { f, schemas }
}
}
impl<'a, F: Fn(AccountNumber, AccountNumber) -> ()> CustomHandler
for CustomPrettyActionCollectAccounts<'a, F>
{
fn matches(&self, schema: &CompiledSchema, ty: &CompiledType) -> bool {
schema.matches_action(ty)
}
fn frac2json(
&self,
_schema: &CompiledSchema,
_ty: &CompiledType,
_src: &mut FracInputStream,
_allow_empty_container: bool,
) -> Result<serde_json::Value, fracpack::Error> {
unimplemented!()
}
fn json2frac(
&self,
parent_schema: &CompiledSchema,
ty: &CompiledType,
val: &serde_json::Value,
dest: &mut Vec<u8>,
) -> Result<(), serde_json::Error> {
let (sender, service, method, _raw_data_name) = deserialize_pretty_action(ty, val)?;
(self.f)(sender, service);
if let Some(data) = val.get("data") {
if let Some(schema) = self.schemas.get(&service) {
if let Some(action_type) = schema.actions.get(&MethodString(method.to_string())) {
let mut cschema =
CompiledSchema::new(&schema.types, parent_schema.get_custom());
cschema.extend(&action_type.params);
cschema.from_value(&action_type.params, data)?;
}
}
}
Action {
sender,
service,
method,
rawData: Vec::<u8>::new().into(),
}
.pack(dest);
Ok(())
}
fn fracpack_verify(
&self,
_schema: &CompiledSchema,
_ty: &CompiledType,
_src: &mut FracInputStream,
_allow_empty_container: bool,
) -> Result<(), fracpack::Error> {
unimplemented!()
}
fn is_empty_container(&self, _ty: &CompiledType, _value: &serde_json::Value) -> bool {
false
}
}
fn translate_flags(flags: &[String]) -> Result<u64, Error> {
let mut result = 0;
for flag in flags {
result |= match flag.as_str() {
"isPrivileged" => CodeRow::IS_PRIVILEGED,
"isVerify" => CodeRow::IS_VERIFY,
"isReplacement" => CodeRow::IS_REPLACEMENT,
_ => Err(Error::InvalidFlags)?,
};
}
Ok(result)
}
fn translate_local_flags(flags: &[String]) -> Result<String, Error> {
let mut result = String::new();
for flag in flags {
match flag.as_str() {
"isPrivileged" => {}
"isReplacement" => {}
_ => Err(Error::InvalidFlags)?,
};
if result.is_empty() {
result += "?";
} else {
result += "&";
}
result += flag;
result += "=1";
}
Ok(result)
}
fn read<T: Read>(reader: &mut T) -> Result<Vec<u8>, anyhow::Error> {
let mut result = vec![];
reader.read_to_end(&mut result)?;
Ok(result)
}
impl<R: Read + Seek> PackagedService<R> {
pub fn new(mut reader: R) -> Result<Self, anyhow::Error> {
let mut hasher = Sha256::new();
std::io::copy(&mut reader, &mut hasher)?;
let hash: [u8; 32] = hasher.finalize().into();
reader.rewind()?;
Self::prehashed(reader, hash.into())
}
pub fn prehashed(reader: R, hash: Checksum256) -> Result<Self, anyhow::Error> {
let mut archive = ZipArchive::new(reader)?;
let mut info_files: HashMap<AccountNumber, usize> = HashMap::new();
let mut service_files: Vec<(AccountNumber, usize)> = vec![];
let mut data = vec![];
let mut meta_index = None;
let service_re = Regex::new(r"^service/([-a-zA-Z0-9]*(?:/\d+)?)\.(wasm|json)$")?;
let data_re = Regex::new(r"^data/([-a-zA-Z0-9]*)/.*$")?;
for index in 0..archive.len() {
let raw_file = archive.by_index_raw(index)?;
let filename = raw_file.name();
if filename == "meta.json" {
meta_index = Some(index)
} else if let Some(captures) = service_re.captures(filename) {
match captures.extract() {
(_, [name, "wasm"]) => {
service_files.push((name.replace("/", "+").parse()?, index));
}
(_, [name, "json"]) => {
info_files.insert(name.replace("/", "+").parse()?, index);
}
_ => {}
}
} else if let Some(captures) = data_re.captures(filename) {
if raw_file.is_file() {
let (_, [name]) = captures.extract();
data.push((AccountNumber::from_str(name)?, index));
}
}
}
let meta_contents =
std::io::read_to_string(archive.by_index(meta_index.ok_or(Error::MissingMeta)?)?)?;
let meta: Meta = serde_json::de::from_str(&meta_contents)?;
let mut services = vec![];
for (account, file) in service_files {
if !meta.accounts.contains(&account) {
Err(Error::UnknownAccount { name: account })?
}
let info = match info_files.get(&account) {
Some(info_idx) => serde_json::de::from_reader(archive.by_index(*info_idx)?)?,
None => ServiceInfo {
flags: vec![],
server: None,
schema: None,
},
};
services.push((account, file, info));
}
for (account, _file) in &data[..] {
if !meta.accounts.contains(&account) {
Err(Error::UnknownAccount { name: *account })?
}
}
let postinstall = if let Ok(file) = archive.by_name("script/postinstall.json") {
serde_json::de::from_str::<Vec<PrettyAction>>(&std::io::read_to_string(file)?)?
} else {
Vec::new()
};
Ok(PackagedService {
archive: archive,
meta: meta,
services: services,
data: data,
postinstall,
hash,
})
}
pub fn name(&self) -> &str {
&self.meta.name
}
pub fn version(&self) -> &str {
&self.meta.version
}
pub fn meta(&self) -> &Meta {
&self.meta
}
pub fn hash(&self) -> &Checksum256 {
&self.hash
}
pub fn get_genesis(&mut self, services: &mut Vec<GenesisService>) -> Result<(), anyhow::Error> {
for (account, index, info) in &self.services {
services.push(GenesisService {
service: *account,
flags: translate_flags(&info.flags)?,
vmType: 0,
vmVersion: 0,
code: read(&mut self.archive.by_index(*index)?)?.into(),
})
}
Ok(())
}
pub fn install_code(&mut self, actions: &mut Vec<Action>) -> Result<(), anyhow::Error> {
for (account, index, info) in &self.services {
actions.push(set_code_action(
*account,
read(&mut self.archive.by_index(*index)?)?.into(),
));
let flags = translate_flags(&info.flags)?;
if flags != 0 {
actions.push(setcode::Wrapper::pack().setFlags(*account, flags));
}
}
Ok(())
}
pub fn set_schema(&mut self, actions: &mut Vec<Action>) -> Result<(), anyhow::Error> {
for (account, _, info) in &self.services {
if let Some(schema) = &info.schema {
actions.push(packages::Wrapper::pack_from(*account).setSchema(schema.clone()))
}
}
Ok(())
}
pub fn has_service(&self, service: AccountNumber) -> bool {
for (account, _, _) in &self.services {
if *account == service {
return true;
}
}
false
}
pub fn store_data(
&mut self,
actions: &mut Vec<Action>,
mut uploader: Option<&mut StagedUpload>,
compression_level: u32,
) -> Result<(), anyhow::Error> {
let data_re = Regex::new(r"^data/[-a-zA-Z0-9]*(/.*)$")?;
for (sender, index) in &self.data {
let mut file = self.archive.by_index(*index)?;
let file_name = file.name().to_string();
let path = data_re
.captures(&file_name)
.unwrap()
.get(1)
.unwrap()
.as_str();
if let Some(t) = mime_guess::from_path(path).first() {
let content = read(&mut file)?;
let (content, content_encoding) =
compress_content(&content, t.essence_str(), compression_level);
if let Some(uploader) = &mut uploader {
let index = uploader.next_file_index();
let tmp_path = format!("/.staged/{:016X}/{}", uploader.id, index);
let tmp_sender = uploader.sender;
let content_hash: [u8; 32] = Sha256::digest(&content).into();
uploader.actions.push(
sites::Wrapper::pack_from_to(tmp_sender, sites::SERVICE).storeSys(
tmp_path.clone(),
t.essence_str().to_string(),
content_encoding.clone(),
content.into(),
),
);
actions.push(
sites::Wrapper::pack_from_to(*sender, sites::SERVICE).hardlink(
path.to_string(),
t.essence_str().to_string(),
content_encoding,
content_hash.into(),
),
);
actions.push(
sites::Wrapper::pack_from_to(tmp_sender, sites::SERVICE)
.remove(tmp_path.to_string()),
);
} else {
actions.push(
sites::Wrapper::pack_from_to(*sender, sites::SERVICE).storeSys(
path.to_string(),
t.essence_str().to_string(),
content_encoding,
content.into(),
),
);
}
} else {
Err(Error::UnknownFileType {
path: file.name().to_string(),
})?
}
}
Ok(())
}
pub fn reg_server(&mut self, actions: &mut Vec<Action>) -> Result<(), anyhow::Error> {
for (account, _, info) in &self.services {
if let Some(server) = &info.server {
actions.push(http_server::Wrapper::pack_from(*account).registerServer(*server))
}
}
Ok(())
}
pub fn get_accounts(&self) -> &[AccountNumber] {
&self.meta.accounts
}
pub fn get_services(&self) -> &[AccountNumber] {
&self.meta.services
}
pub fn read_postinstall(&mut self) -> Result<Vec<PrettyAction>, anyhow::Error> {
Ok(self.postinstall.clone())
}
pub fn postinstall(
&mut self,
schemas: &SchemaMap,
actions: &mut Vec<Action>,
) -> Result<(), anyhow::Error> {
actions.append(
&mut self
.postinstall
.iter()
.map(|act| act.to_action(schemas))
.collect::<Result<Vec<Action>, anyhow::Error>>()
.with_context(|| format!("Invalid postinstall script for {}", self.meta.name))?,
);
Ok(())
}
pub fn needs_ui(&mut self) -> bool {
self.postinstall
.iter()
.any(|act| act.service.parse().unwrap_or(AccountNumber::new(0)) == sites::SERVICE)
}
fn manifest_services(&self) -> HashMap<AccountNumber, ServiceInfo> {
let mut result = HashMap::new();
for (service, _, info) in &self.services {
result.insert(*service, info.clone());
}
result
}
fn manifest_data(&self) -> Vec<PackageDataFile> {
let mut manifest = vec![];
let data_re = Regex::new(r"^data/[-a-zA-Z0-9]*(/.*)$").unwrap();
for (sender, index) in &self.data {
let file = self.archive.name_for_index(*index).unwrap();
let path = data_re.captures(file).unwrap().get(1).unwrap().as_str();
manifest.push(PackageDataFile {
account: *sender,
filename: path.to_string(),
});
}
manifest
}
pub fn manifest(&self) -> PackageManifest {
let services = self.manifest_services();
let data = self.manifest_data();
PackageManifest { services, data }
}
pub fn commit_install(
&mut self,
sender: AccountNumber,
actions: &mut Vec<Action>,
) -> Result<(), anyhow::Error> {
let manifest = self.manifest();
let mut manifest_encoder = GzEncoder::new(Vec::new(), flate2::Compression::default());
serde_json::to_writer(&mut manifest_encoder, &manifest)?;
actions.push(
packages::Wrapper::pack_from(sender)
.postinstall(self.meta.clone(), manifest_encoder.finish()?.into()),
);
Ok(())
}
pub fn create_account(
&self,
account: AccountNumber,
sender: AccountNumber,
actions: &mut Vec<Action>,
) -> Result<(), anyhow::Error> {
if let Some(preapprove) = preapprove_action(sender, account) {
actions.push(preapprove)
}
actions.push(new_account_owned_action(sender, account, sender));
Ok(())
}
pub fn install_account_group(
&mut self,
actions: &mut Vec<Vec<Action>>,
mut uploader: &mut Option<&mut StagedUpload>,
sender: AccountNumber,
subaccounts: bool,
) -> Result<(), anyhow::Error> {
for (account, index, info) in &self.services {
if account.is_subaccount() != subaccounts {
continue;
}
let mut group = vec![];
self.create_account(*account, sender, &mut group)?;
let code = read(&mut self.archive.by_index(*index)?)?;
let code_hash: [u8; 32] = Sha256::digest(&code).into();
if let Some(uploader) = &mut uploader {
uploader
.actions
.push(setcode::Wrapper::pack_from(uploader.sender).stageCode(
*account,
uploader.id.clone(),
0,
0,
code.into(),
));
group.push(setcode::Wrapper::pack_from(*account).setCodeStaged(
uploader.sender,
uploader.id.clone(),
0,
0,
code_hash.into(),
));
} else {
group.push(set_code_action(*account, code.into()));
}
let flags = translate_flags(&info.flags)?;
if flags != 0 {
group.push(setcode::Wrapper::pack().setFlags(*account, flags));
}
if let Some(schema) = &info.schema {
group.push(packages::Wrapper::pack_from(*account).setSchema(schema.clone()))
}
actions.push(group);
}
for account in self.get_accounts() {
if account.is_subaccount() != subaccounts {
continue;
}
if !self.has_service(*account) {
let mut group = vec![];
self.create_account(*account, sender, &mut group)?;
actions.push(group);
}
}
Ok(())
}
pub fn install_accounts(
&mut self,
actions: &mut Vec<Vec<Action>>,
mut uploader: Option<&mut StagedUpload>,
sender: AccountNumber,
) -> Result<(), anyhow::Error> {
self.install_account_group(actions, &mut uploader, sender, false)?;
self.install_account_group(actions, &mut uploader, sender, true)
}
pub fn install(
&mut self,
actions: &mut Vec<Action>,
uploader: Option<&mut StagedUpload>,
sender: AccountNumber,
install_ui: bool,
compression_level: u32,
schemas: &SchemaMap,
packages: &PackageList,
) -> Result<(), anyhow::Error> {
if install_ui {
self.reg_server(actions)?;
self.store_data(actions, uploader, compression_level)?;
}
self.link(packages, actions)?;
self.postinstall(schemas, actions)?;
self.commit_install(sender, actions)?;
Ok(())
}
pub fn get_required_accounts(
&self,
schemas: &SchemaMap,
) -> Result<(Vec<AccountNumber>, Vec<AccountNumber>), anyhow::Error> {
let mut accounts = vec![];
let mut services = vec![];
let local = &self.meta.scope == "local";
if !self.data.is_empty() {
if !local {
services.push(sites::SERVICE);
} else {
services.push(x_sites::SERVICE);
}
}
for (_, _, info) in &self.services {
if let Some(_) = &info.server {
if !local {
services.push(http_server::SERVICE)
} else {
}
}
}
for account in &self.meta.accounts {
if account.is_subaccount() {
accounts.push(account.base());
}
}
for act in &self.postinstall {
act.get_required_accounts(&mut accounts, &mut services, schemas)?;
}
accounts.sort_unstable_by(|a, b| a.value.cmp(&b.value));
accounts.dedup();
services.sort_unstable_by(|a, b| a.value.cmp(&b.value));
services.dedup();
Ok((accounts, services))
}
pub fn get_schemas(
&self,
accounts: &mut HashSet<AccountNumber>,
schemas: &mut SchemaMap,
) -> Result<(), anyhow::Error> {
for (account, _, info) in &self.services {
if accounts.remove(account) {
schemas.insert(
*account,
info.schema
.clone()
.ok_or_else(|| Error::MissingSchema { service: *account })?,
);
}
}
Ok(())
}
pub fn get_all_schemas(&self, schemas: &mut SchemaMap) -> Result<(), anyhow::Error> {
for (account, _, info) in &self.services {
if !schemas.contains_key(account) {
if let Some(schema) = info.schema.clone() {
schemas.insert(*account, schema);
}
}
}
Ok(())
}
pub async fn load_schemas<F: SchemaFetcher>(
&self,
fetcher: &F,
schemas: &mut SchemaMap,
) -> Result<(), anyhow::Error> {
self.get_all_schemas(schemas)?;
for act in &self.postinstall {
act.load_schemas(fetcher, schemas).await?
}
Ok(())
}
fn linked_services(&self) -> Vec<AccountNumber> {
let mut visited = HashSet::new();
let mut services = Vec::new();
for (service, _, _) in &self.services {
if visited.insert(*service) {
services.push(*service)
}
}
for (service, _) in &self.data {
if visited.insert(*service) {
services.push(*service)
}
}
services
}
pub fn link<A: ActionSink>(
&self,
packages: &PackageList,
actions: &mut A,
) -> Result<(), anyhow::Error> {
let mut visited_imports = HashMap::new();
let mut imports = Vec::new();
for export in &self.meta.exports {
imports.push(dyn_ld::DynDep {
name: export.name.clone(),
service: export.service.clone(),
});
}
for dep in &self.meta.depends {
let Some((meta, _)) = packages.get_by_ref(dep)? else {
Err(anyhow!(
"Package list does not contain {}-{}",
dep.name,
dep.version
))?
};
for export in &meta.exports {
if let Some(old) = visited_imports.insert(&export.name, export.service) {
if old != export.service {
Err(anyhow!("Ambiguous import for {}", export.name))?
}
} else {
imports.push(dyn_ld::DynDep {
name: export.name.clone(),
service: export.service.clone(),
})
}
}
}
for service in self.linked_services() {
actions.push_action(
dyn_ld::Wrapper::pack_from(service).link(self.meta.name.clone(), imports.clone()),
)?
}
Ok(())
}
#[cfg(not(target_family = "wasm"))]
pub async fn install_local(
&mut self,
base_url: &reqwest::Url,
client: &mut reqwest::Client,
_compression_level: u32,
) -> Result<(), anyhow::Error> {
for (account, index, info) in &self.services {
if let Some(server) = &info.server {
crate::as_text(
client
.post(x_http::SERVICE.url(base_url)?.join("/register_server")?)
.body(serde_json::to_string(&x_http::RegisterServerRequest {
service: *account,
server: *server,
})?)
.header("Content-Type", "application/json"),
)
.await?;
}
crate::as_text(
client
.put(x_admin::SERVICE.url(base_url)?.join(&format!(
"/services/{}{}",
account,
translate_local_flags(&info.flags)?
))?)
.body(read(&mut self.archive.by_index(*index)?)?)
.header("Content-Type", "application/wasm"),
)
.await?;
}
let data_re = Regex::new(r"^data/[-a-zA-Z0-9]*(/.*)$")?;
for (sender, index) in &self.data {
let mut file = self.archive.by_index(*index)?;
let file_name = file.name().to_string();
let path = data_re
.captures(&file_name)
.unwrap()
.get(1)
.unwrap()
.as_str();
if let Some(t) = mime_guess::from_path(path).first() {
let content = read(&mut file)?;
let builder = client
.put(sender.url(base_url)?.join(path)?)
.header("Content-Type", t.essence_str().to_string())
.body(content);
crate::as_text(builder).await?;
} else {
Err(Error::UnknownFileType {
path: file.name().to_string(),
})?
}
}
Ok(())
}
}
impl<R: Read + Seek> PackagedService<R> {
pub fn services(&mut self) -> impl Iterator<Item = (&AccountNumber, &ServiceInfo, Vec<u8>)> {
let archive = &mut self.archive;
self.services.iter().map(|(account, index, info)| {
let mut file = archive.by_index(*index).unwrap();
(account, info, read(&mut file).unwrap())
})
}
pub fn data(&mut self) -> impl Iterator<Item = (&AccountNumber, String, Vec<u8>)> {
let archive = &mut self.archive;
let data_re = Regex::new(r"^data/[-a-zA-Z0-9]*(/.*)$").unwrap();
self.data.iter().map(move |(account, index)| {
let mut file = archive.by_index(*index).unwrap();
let file_name = file.name().to_string();
let path = data_re
.captures(&file_name)
.unwrap()
.get(1)
.unwrap()
.as_str();
(account, path.to_string(), read(&mut file).unwrap())
})
}
}
pub fn get_schemas<T: Read + Seek>(
packages: &[PackagedService<T>],
) -> Result<SchemaMap, anyhow::Error> {
let mut schemas = HashMap::new();
for package in &packages[..] {
package.get_all_schemas(&mut schemas)?
}
Ok(schemas)
}
pub trait ActionGroup {
fn append_to_tx(self, trx_actions: &mut Vec<Action>, size: &mut usize);
}
impl ActionGroup for Action {
fn append_to_tx(self, trx_actions: &mut Vec<Action>, size: &mut usize) {
*size += self.rawData.len();
trx_actions.push(self);
}
}
impl ActionGroup for Vec<Action> {
fn append_to_tx(self, trx_actions: &mut Vec<Action>, size: &mut usize) {
for act in self {
act.append_to_tx(trx_actions, size);
}
}
}
pub trait ActionSink {
fn push_action<T: ActionGroup>(&mut self, act: T) -> Result<(), anyhow::Error>;
}
impl ActionSink for Vec<Action> {
fn push_action<T: ActionGroup>(&mut self, act: T) -> Result<(), anyhow::Error> {
let mut size = 0;
act.append_to_tx(self, &mut size);
Ok(())
}
}
pub struct StagedUpload {
pub id: u64,
pub sender: AccountNumber,
pub actions: Vec<Action>,
file_index: u32,
}
impl StagedUpload {
pub fn new(id: u64, sender: AccountNumber) -> Self {
StagedUpload {
id,
sender,
actions: Vec::new(),
file_index: 0,
}
}
fn next_file_index(&mut self) -> u32 {
let result = self.file_index;
self.file_index += 1;
result
}
}
impl PackageManifest {
pub fn upgrade<T: ActionSink>(
&self,
other: PackageManifest,
package_name: &str,
out: &mut T,
) -> Result<(), anyhow::Error> {
let new_linked_services = other.linked_services_set();
let new_files: HashSet<_> = other.data.into_iter().collect();
for file in &self.data {
if !new_files.contains(file) {
out.push_action(
sites::Wrapper::pack_from(file.account).remove(file.filename.clone()),
)?;
}
}
for (service, info) in &self.services {
let other_info = other.services.get(service);
if info.server.is_some() && other_info.map_or(true, |i| i.server.is_none()) {
out.push_action(reg_server(*service, sites::SERVICE))?;
}
if !info.flags.is_empty() && other_info.map_or(true, |i| i.flags.is_empty()) {
out.push_action(setcode::Wrapper::pack().setFlags(*service, 0))?;
}
if other_info.is_none() {
out.push_action(set_code_action(*service, vec![]))?;
}
}
for service in self.linked_services(new_linked_services) {
out.push_action(dyn_ld::Wrapper::pack_from(service).unlink(package_name.to_string()))?;
}
Ok(())
}
pub fn remove<T: ActionSink>(
&self,
package_name: &str,
out: &mut T,
) -> Result<(), anyhow::Error> {
for file in &self.data {
out.push_action(sites::Wrapper::pack_from(file.account).remove(file.filename.clone()))?;
}
for (service, info) in &self.services {
if info.server.is_some() {
out.push_action(reg_server(*service, sites::SERVICE))?;
}
if !info.flags.is_empty() {
out.push_action(setcode::Wrapper::pack().setFlags(*service, 0))?;
}
out.push_action(set_code_action(*service, vec![]))?;
}
for service in self.linked_services(HashSet::new()) {
out.push_action(dyn_ld::Wrapper::pack_from(service).unlink(package_name.to_string()))?;
}
Ok(())
}
fn linked_services_set(&self) -> HashSet<AccountNumber> {
let mut visited = HashSet::new();
for file in &self.data {
visited.insert(file.account);
}
for (service, _) in &self.services {
visited.insert(*service);
}
visited
}
fn linked_services(&self, mut visited: HashSet<AccountNumber>) -> Vec<AccountNumber> {
let mut services = Vec::new();
for file in &self.data {
if visited.insert(file.account) {
services.push(file.account)
}
}
for (service, _) in &self.services {
if visited.insert(*service) {
services.push(*service)
}
}
services
}
}
#[cfg(not(target_family = "wasm"))]
impl PackageManifest {
pub async fn upgrade_local(
&self,
base_url: &reqwest::Url,
client: &mut reqwest::Client,
other: PackageManifest,
) -> Result<(), anyhow::Error> {
let new_files: HashSet<_> = other.data.into_iter().collect();
for file in &self.data {
if !new_files.contains(file) {
crate::as_text(client.delete(file.account.url(base_url)?.join(&file.filename)?))
.await?;
}
}
for (service, _info) in &self.services {
let other_info = other.services.get(service);
if other_info.is_none() {
crate::as_text(
client.delete(
x_admin::SERVICE
.url(base_url)?
.join(&format!("/services/{}", service))?,
),
)
.await?;
}
}
Ok(())
}
pub async fn remove_local(
&self,
base_url: &reqwest::Url,
client: &mut reqwest::Client,
) -> Result<(), anyhow::Error> {
for file in &self.data {
crate::as_text(client.delete(file.account.url(base_url)?.join(&file.filename)?))
.await?;
}
for (service, _info) in &self.services {
crate::as_text(
client.delete(
x_admin::SERVICE
.url(base_url)?
.join(&format!("/services/{}", service))?,
),
)
.await?;
}
Ok(())
}
}
pub fn validate_dependencies<T: Read + Seek>(
packages: &mut [PackagedService<T>],
schemas: &SchemaMap,
) -> Result<(), anyhow::Error> {
let mut accounts: HashMap<AccountNumber, HashSet<String>> = HashMap::new();
let mut services: HashMap<AccountNumber, String> = HashMap::new();
let mut files: HashMap<PackageDataFile, String> = HashMap::new();
for p in &mut packages[..] {
for account in p.get_accounts() {
accounts
.entry(*account)
.or_insert_with(|| HashSet::new())
.insert(p.meta.name.clone());
}
for (account, _, _) in &p.services {
match services.entry(*account) {
hash_map::Entry::Occupied(entry) => Err(Error::ServiceConflict {
name: *account,
old: entry.get().to_string(),
new: p.meta.name.clone(),
})?,
hash_map::Entry::Vacant(entry) => entry.insert(p.meta.name.clone()),
};
}
for file in p.manifest_data() {
match files.entry(file) {
hash_map::Entry::Occupied(entry) => Err(Error::FileConflict {
name: entry.key().account,
filename: entry.key().filename.to_string(),
old: entry.get().to_string(),
new: p.meta.name.clone(),
})?,
hash_map::Entry::Vacant(entry) => entry.insert(p.meta.name.clone()),
};
}
}
for p in &mut packages[..] {
let (required_accounts, required_services) = p.get_required_accounts(schemas)?;
for account in required_accounts {
if let Some(packages) = accounts.get(&account) {
if !packages.contains(&p.meta.name)
&& !p
.meta
.depends
.iter()
.any(|dep| packages.contains(&dep.name))
{
Err(Error::MissingDepPackage {
name: p.meta.name.clone(),
dep: packages.iter().next().unwrap().clone(),
})?;
}
} else {
Err(Error::MissingDepAccount {
name: account,
package: p.meta.name.clone(),
})?
}
}
for account in required_services {
if let Some(package) = services.get(&account) {
if &p.meta.name != package && !p.meta.depends.iter().any(|dep| &dep.name == package)
{
Err(Error::MissingDepPackage {
name: p.meta.name.clone(),
dep: package.clone(),
})?;
}
} else {
Err(Error::MissingDepAccount {
name: account,
package: p.meta.name.clone(),
})?
}
}
}
Ok(())
}
pub enum PackageOpFull<R: Read + Seek> {
Install(PackagedService<R>),
Replace(Meta, PackagedService<R>),
Remove(Meta),
}
impl<R: Read + Seek> PackageOpFull<R> {
pub fn name(&self) -> &str {
match self {
PackageOpFull::Install(package) | PackageOpFull::Replace(_, package) => package.name(),
PackageOpFull::Remove(meta) => &meta.name,
}
}
pub fn old(&self) -> Option<&Meta> {
match self {
PackageOpFull::Install(_) => None,
PackageOpFull::Replace(meta, _) | PackageOpFull::Remove(meta) => Some(meta),
}
}
pub fn new(&mut self) -> Option<&mut PackagedService<R>> {
match self {
PackageOpFull::Install(package) | PackageOpFull::Replace(_, package) => Some(package),
PackageOpFull::Remove(_) => None,
}
}
}
pub async fn fetch_all_schemas<R: Read + Seek, F: SchemaFetcher>(
packages: &Vec<PackageOpFull<R>>,
fetcher: &F,
schemas: &mut SchemaMap,
) -> Result<(), anyhow::Error> {
for op in packages {
match op {
PackageOpFull::Install(package) | PackageOpFull::Replace(_, package) => {
package.get_all_schemas(schemas)?
}
_ => {}
}
}
for op in packages {
match op {
PackageOpFull::Install(package) | PackageOpFull::Replace(_, package) => {
package.load_schemas(fetcher, schemas).await?
}
_ => {}
}
}
Ok(())
}
pub async fn fetch_packages<R: PackageRegistry + ?Sized, F: SchemaFetcher>(
reg: &R,
ops: Vec<PackageOp>,
existing: &PackageList,
fetcher: &F,
schemas: &mut SchemaMap,
essential_services: &EssentialServices,
) -> Result<Vec<PackageOpFull<R::R>>, anyhow::Error> {
let mut result = Vec::with_capacity(ops.len());
for op in ops {
result.push(match op {
PackageOp::Install(info) => PackageOpFull::Install(reg.get_by_info(&info).await?),
PackageOp::Replace(meta, info) => {
PackageOpFull::Replace(meta, reg.get_by_info(&info).await?)
}
PackageOp::Remove(meta) => PackageOpFull::Remove(meta),
})
}
fetch_all_schemas(&result, fetcher, schemas).await?;
sort_package_ops(&mut result, existing, schemas, essential_services)?;
Ok(result)
}
fn get_transitive_services<'a>(
package: &'a str,
deps: &'a HashMap<String, &Vec<PackageRef>>,
visited: &mut HashSet<&'a str>,
out: &mut Vec<String>,
) -> Result<(), anyhow::Error> {
if let Some(children) = deps.get(package) {
if visited.insert(package) {
out.push(package.to_string());
for dep in *children {
get_transitive_services(&dep.name, deps, visited, out)?;
}
}
}
Ok(())
}
fn build_package_order_graph<R: Read + Seek>(
packages: &Vec<PackageOpFull<R>>,
existing: &PackageList,
schemas: &SchemaMap,
) -> Result<HashMap<String, Vec<String>>, anyhow::Error> {
let mut result: HashMap<String, Vec<String>> = HashMap::new();
let mut provides_service: HashMap<AccountNumber, &Meta> = HashMap::new();
let mut service_deps = HashMap::new();
for package in packages {
match package {
PackageOpFull::Install(package) | PackageOpFull::Replace(_, package) => {
for (service, _, _) in &package.services {
if let Some(prev) = provides_service.insert(*service, package.meta()) {
Err(Error::ServiceConflict {
name: *service,
old: prev.name.clone(),
new: package.name().to_string(),
})?
}
}
if !package.services.is_empty() {
service_deps.insert(package.name().to_string(), &package.meta().depends);
}
}
PackageOpFull::Remove(_) => {}
}
}
let mut updated_packages: HashSet<&str> = HashSet::new();
for package in packages {
match package {
PackageOpFull::Install(package) => {
updated_packages.insert(package.name());
}
PackageOpFull::Replace(meta, package) => {
updated_packages.insert(&meta.name);
updated_packages.insert(package.name());
}
PackageOpFull::Remove(meta) => {
updated_packages.insert(&meta.name);
}
}
}
for (name, versions) in &existing.packages {
if !updated_packages.contains(&name.as_str()) {
for (_version, (meta, _origin)) in versions {
for service in &meta.services {
if let Some(prev) = provides_service.insert(*service, meta) {
Err(Error::ServiceConflict {
name: *service,
old: name.clone(),
new: prev.name.clone(),
})?
}
}
if !meta.services.is_empty() {
service_deps.insert(name.clone(), &meta.depends);
}
}
}
}
for package in packages {
match package {
PackageOpFull::Install(package) | PackageOpFull::Replace(_, package) => {
let mut all_required_packages = Vec::new();
let mut visited = HashSet::new();
for service in package.get_required_accounts(schemas)?.1 {
let Some(required_package) = provides_service.get(&service) else {
Err(Error::MissingDepAccount {
name: service,
package: package.name().to_string(),
})?
};
if &required_package.name != package.name() {
if visited.insert(required_package.name.as_str()) {
all_required_packages.push(required_package.name.clone());
}
}
for dep in &required_package.depends {
get_transitive_services(
&dep.name,
&service_deps,
&mut visited,
&mut all_required_packages,
)?;
}
}
all_required_packages.retain(|name| updated_packages.contains(&name.as_str()));
result.insert(package.name().to_string(), all_required_packages);
}
PackageOpFull::Remove(_) => {
}
}
}
Ok(result)
}
fn topological_sort_impl(
vertex: &str,
graph: &HashMap<String, Vec<String>>,
indexes: &HashMap<String, usize>,
out: &mut Vec<usize>,
mut i: usize,
) -> Result<usize, anyhow::Error> {
const NEW: usize = usize::MAX;
const ON_STACK: usize = NEW - 1;
let index = *indexes.get(vertex).unwrap();
if out[index] == ON_STACK {
Err(Error::DependencyCycle {
package: vertex.to_string(),
})?
} else if out[index] == NEW {
out[index] = ON_STACK;
let Some(edges) = graph.get(vertex) else {
Err(anyhow!("Missing vertex {vertex}"))?
};
for edge in edges {
i = topological_sort_impl(edge.as_str(), graph, indexes, out, i)
.with_context(|| format!("Installing {vertex}"))?;
}
out[index] = i;
i += 1;
}
Ok(i)
}
fn get_package_order<R: Read + Seek>(
packages: &Vec<PackageOpFull<R>>,
existing: &PackageList,
schemas: &SchemaMap,
essential_services: &EssentialServices,
) -> Result<Vec<usize>, anyhow::Error> {
let mut permutation = vec![usize::MAX; packages.len()];
let mut indexes = HashMap::new();
for (i, package) in packages.iter().enumerate() {
indexes.insert(package.name().to_string(), i);
}
let graph = build_package_order_graph(packages, existing, schemas)?;
let mut i = 0;
for package in packages {
match package {
PackageOpFull::Install(package) | PackageOpFull::Replace(_, package) => {
if essential_services.intersects(&package.meta().accounts) {
i = topological_sort_impl(
package.name(),
&graph,
&indexes,
&mut permutation,
i,
)?;
}
}
PackageOpFull::Remove(_) => {}
}
}
for package in packages {
i = topological_sort_impl(package.name(), &graph, &indexes, &mut permutation, i)?;
}
Ok(permutation)
}
fn apply_permutation<T>(vec: &mut Vec<T>, permutation: &mut [usize]) {
assert!(vec.len() == permutation.len());
for i in 0..vec.len() {
while permutation[i] != i {
let pos = permutation[i];
permutation.swap(i, pos);
vec.swap(i, pos);
}
}
}
pub fn sort_package_ops<R: Read + Seek>(
packages: &mut Vec<PackageOpFull<R>>,
existing: &PackageList,
schemas: &SchemaMap,
essential_services: &EssentialServices,
) -> Result<(), anyhow::Error> {
let mut order = get_package_order(packages, existing, schemas, essential_services)?;
apply_permutation(packages, &mut order);
Ok(())
}
pub fn make_refs(packages: &[String]) -> Result<Vec<PackageRef>, anyhow::Error> {
let re = Regex::new(
r"^(.*?)(?:-(\d+(?:\.\d+(?:\.\d+(?:-[0-9a-zA-Z-.]+)?(?:\+[0-9a-zA-Z-.]+)?)?)?))?$",
)?;
let mut refs = vec![];
for package in packages {
if let Some(captures) = re.captures(package) {
let name = captures.get(1).unwrap().as_str();
let version = captures
.get(2)
.map_or("*".to_string(), |m| "=".to_string() + m.as_str());
refs.push(PackageRef {
name: name.to_string(),
version: version,
});
}
}
Ok(refs)
}
pub fn make_ref(package: &str) -> Result<PackageRef, anyhow::Error> {
Ok(make_refs(&[package.to_string()])?.pop().unwrap())
}
#[derive(Debug, Clone)]
pub struct EssentialServices {
remaining: Vec<AccountNumber>,
}
impl EssentialServices {
pub fn empty() -> Self {
Self {
remaining: Vec::new(),
}
}
pub fn with_key(block_signing_key: &Option<AnyPublicKey>) -> Self {
let mut remaining = vec![transact::SERVICE, producers::SERVICE, setcode::SERVICE];
if let Some(key) = block_signing_key {
remaining.push(key.key.service)
}
Self { remaining }
}
pub fn remove(&mut self, accounts: &[AccountNumber]) {
for account in accounts {
if let Some(idx) = self.remaining.iter().position(|a| a == account) {
self.remaining.swap_remove(idx);
}
}
}
pub fn is_empty(&self) -> bool {
self.remaining.is_empty()
}
pub fn intersects(&self, accounts: &[AccountNumber]) -> bool {
for account in accounts {
if self.remaining.iter().find(|a| *a == account).is_some() {
return true;
}
}
return false;
}
}
#[async_trait(?Send)]
pub trait PackageRegistry {
type R: Read + Seek;
fn index(&self) -> Result<Vec<PackageInfo>, anyhow::Error>;
async fn get_by_info(
&self,
info: &PackageInfo,
) -> Result<PackagedService<Self::R>, anyhow::Error>;
async fn resolve(
&self,
packages: &[String],
local: bool,
essential_services: &EssentialServices,
) -> Result<Vec<PackagedService<Self::R>>, anyhow::Error> {
let installed = PackageList::new();
let packages = installed
.resolve_changes(self, packages, false, local)
.await?;
let mut schemas = SchemaMap::new();
Ok(fetch_packages(
self,
packages,
&installed,
&NullSchemaFetcher,
&mut schemas,
essential_services,
)
.await?
.into_iter()
.map(|op| {
if let PackageOpFull::Install(package) = op {
package
} else {
panic!("Only install is expected when there are no existing packages")
}
})
.collect())
}
}
pub struct DirectoryRegistry {
dir: PathBuf,
index: PathBuf,
}
impl DirectoryRegistry {
pub fn new(path: PathBuf) -> Self {
if path.is_dir() {
let index = path.join("index.json");
DirectoryRegistry { dir: path, index }
} else {
let dir = path.parent().unwrap().to_path_buf();
DirectoryRegistry { dir, index: path }
}
}
}
#[async_trait(?Send)]
impl PackageRegistry for DirectoryRegistry {
type R = BufReader<File>;
fn index(&self) -> Result<Vec<PackageInfo>, anyhow::Error> {
let f = File::open(&self.index)
.with_context(|| format!("Cannot open {}", self.index.to_string_lossy()))?;
let contents = std::io::read_to_string(f)?;
let result: Vec<PackageInfo> = serde_json::de::from_str(&contents)?;
Ok(result)
}
async fn get_by_info(
&self,
info: &PackageInfo,
) -> Result<PackagedService<Self::R>, anyhow::Error> {
let path = self.dir.join(&info.file);
let f =
File::open(&path).with_context(|| format!("Cannot open {}", path.to_string_lossy()))?;
PackagedService::new(BufReader::new(f))
}
}
pub struct FileSetRegistry {
info: Vec<PackageInfo>,
by_hash: HashMap<Checksum256, PathBuf>,
}
impl FileSetRegistry {
pub fn from_files(
packages: &[OsString],
) -> Result<(FileSetRegistry, Vec<String>), anyhow::Error> {
let mut not_files = Vec::new();
let mut result = FileSetRegistry {
info: Vec::new(),
by_hash: HashMap::new(),
};
for package in packages {
let path: &Path = package.as_ref();
if path.exists() {
let mut f =
File::open(path).with_context(|| format!("Cannot open {}", path.display()))?;
let mut hasher = Sha256::new();
std::io::copy(&mut f, &mut hasher)?;
let hash: [u8; 32] = hasher.finalize().into();
f.rewind()?;
let mut archive = ZipArchive::new(f)?;
let meta_contents = std::io::read_to_string(archive.by_name("meta.json")?)?;
let meta: Meta = serde_json::de::from_str(&meta_contents)?;
let sha256 = Checksum256::from(hash);
not_files.push(format!("{}-{}", meta.name, meta.version));
if result
.by_hash
.insert(sha256.clone(), PathBuf::from(path))
.is_none()
{
result
.info
.push(meta.info(sha256, path.display().to_string()));
}
} else {
not_files.push(
path.to_str()
.ok_or_else(|| anyhow!("{} is not valid UTF8", path.display()))?
.to_string(),
);
}
}
Ok((result, not_files))
}
}
#[async_trait(?Send)]
impl PackageRegistry for FileSetRegistry {
type R = BufReader<File>;
fn index(&self) -> Result<Vec<PackageInfo>, anyhow::Error> {
Ok(self.info.clone())
}
async fn get_by_info(
&self,
info: &PackageInfo,
) -> Result<PackagedService<Self::R>, anyhow::Error> {
let path = self.by_hash.get(&info.sha256).unwrap();
let f = File::open(&path).with_context(|| format!("Cannot open {}", info.file))?;
PackagedService::new(BufReader::new(f))
}
}
#[cfg(not(target_family = "wasm"))]
pub struct HTTPRegistry {
index_url: reqwest::Url,
client: reqwest::Client,
index: Vec<PackageInfo>,
}
#[cfg(not(target_family = "wasm"))]
impl HTTPRegistry {
pub async fn new(
url: reqwest::Url,
client: reqwest::Client,
) -> Result<HTTPRegistry, anyhow::Error> {
if let Some(domain) = url.domain() {
if let Ok(rootdomain) =
crate::as_json::<String>(client.get(url.join("/common/rootdomain")?)).await
{
let mut root_url = url.clone();
root_url.set_host(Some(&rootdomain))?;
let account = if domain == &rootdomain {
packages::SERVICE
} else {
crate::as_json::<AccountNumber>(client.get(url.join("/common/thisservice")?))
.await?
};
return Self::with_account(&root_url, account, client).await;
}
}
let mut index_url = url.clone();
index_url
.path_segments_mut()
.unwrap()
.pop_if_empty()
.push("index.json");
let index = crate::as_json::<Vec<PackageInfo>>(client.get(index_url.clone())).await?;
Ok(HTTPRegistry {
index_url,
client,
index,
})
}
pub async fn with_account(
url: &reqwest::Url,
owner: AccountNumber,
mut client: reqwest::Client,
) -> Result<HTTPRegistry, anyhow::Error> {
let mut index = Vec::new();
let mut end_cursor: Option<String> = None;
loop {
let data = crate::gql_query::<PackagesQuery>(
url,
&mut client,
packages::SERVICE,
format!(
"query {{ packages(owner: {}, first: 100, after: {}) {{ pageInfo {{ hasNextPage endCursor }} edges {{ node {{ name version scope description depends {{ name version }} accounts services exports {{ name service }} sha256 file }} }} }} }}",
serde_json::to_string(&owner)?,
serde_json::to_string(&end_cursor)?,
))
.await.with_context(|| "Failed to list packages")?;
for edge in data.packages.edges {
index.push(edge.node);
}
if !data.packages.pageInfo.hasNextPage {
break;
}
end_cursor = Some(data.packages.pageInfo.endCursor);
}
Ok(HTTPRegistry {
index_url: owner.url(url)?,
client,
index,
})
}
pub async fn with_source(
base_url: &reqwest::Url,
source: packages::PackageSource,
client: reqwest::Client,
) -> Result<HTTPRegistry, anyhow::Error> {
match (source.url, source.account) {
(Some(url), Some(account)) => {
Self::with_account(&reqwest::Url::parse(&url)?, account, client).await
}
(None, Some(account)) => Self::with_account(base_url, account, client).await,
(Some(url), None) => Self::new(reqwest::Url::parse(&url)?, client).await,
(None, None) => return Err(Error::InvalidPackageSource)?,
}
}
async fn download(&self, filename: &str) -> Result<(File, Checksum256), anyhow::Error> {
let url = self.index_url.join(filename)?;
if url.origin() != self.index_url.origin() {
Err(Error::CrossOriginFile {
file: filename.to_string(),
})?;
}
let mut response = self.client.get(url).send().await?.error_for_status()?;
let mut hasher = Sha256::new();
let mut f = tempfile()?;
while let Some(chunk) = response.chunk().await? {
f.write_all(&chunk)?;
hasher.update(&chunk);
}
let hash: [u8; 32] = hasher.finalize().into();
f.rewind()?;
Ok((f, Checksum256::from(hash)))
}
}
#[cfg(not(target_family = "wasm"))]
#[async_trait(?Send)]
impl PackageRegistry for HTTPRegistry {
type R = BufReader<File>;
fn index(&self) -> Result<Vec<PackageInfo>, anyhow::Error> {
Ok(self.index.clone())
}
async fn get_by_info(
&self,
info: &PackageInfo,
) -> Result<PackagedService<Self::R>, anyhow::Error> {
let (f, hash) = self.download(&info.file).await?;
if hash != info.sha256 {
Err(Error::PackageDigestFailure {
package: info.name.clone(),
})?
}
let result = PackagedService::new(BufReader::new(f))?;
if result.meta != info.meta() {
Err(Error::PackageMetaMismatch {
package: info.name.clone(),
})?
}
Ok(result)
}
}
pub struct JointRegistry<T: Read + Seek> {
sources: Vec<(PackageList, Box<dyn PackageRegistry<R = T>>)>,
}
impl<T: Read + Seek> JointRegistry<T> {
pub fn new() -> Self {
Self { sources: vec![] }
}
pub fn push<U: PackageRegistry<R = T> + 'static>(
&mut self,
source: U,
) -> Result<(), anyhow::Error> {
let list = PackageList::from_registry(&source)?;
self.sources.push((list, Box::new(source)));
Ok(())
}
}
#[async_trait(?Send)]
impl<T: Read + Seek> PackageRegistry for JointRegistry<T> {
type R = T;
fn index(&self) -> Result<Vec<PackageInfo>, anyhow::Error> {
let mut result = Vec::new();
let mut found = PackageList::new();
for (_, reg) in &self.sources {
for entry in reg.index()? {
if !found.contains_version(&entry.name, &entry.version) {
found.insert_info(entry.clone());
result.push(entry);
}
}
}
Ok(result)
}
async fn get_by_info(
&self,
info: &PackageInfo,
) -> Result<PackagedService<Self::R>, anyhow::Error> {
for (list, reg) in &self.sources {
if list.contains_version(&info.name, &info.version) {
return reg.get_by_info(info).await;
}
}
Err(Error::PackageNotFound {
package: info.name.to_string() + "-" + &info.version,
})?
}
}
pub struct FilteredRegistry<T: PackageRegistry> {
source: T,
local: bool,
}
impl<T: PackageRegistry> FilteredRegistry<T> {
pub fn new(source: T, local: bool) -> Self {
FilteredRegistry { source, local }
}
}
#[async_trait(?Send)]
impl<T: PackageRegistry> PackageRegistry for FilteredRegistry<T> {
type R = T::R;
fn index(&self) -> Result<Vec<PackageInfo>, anyhow::Error> {
let mut result = self.source.index()?;
result.retain(|info| info.is_local() != Some(!self.local));
Ok(result)
}
async fn get_by_info(
&self,
info: &PackageInfo,
) -> Result<PackagedService<Self::R>, anyhow::Error> {
self.source.get_by_info(info).await
}
}
pub enum PackageOrigin {
Installed { owner: AccountNumber },
Repo { sha256: Checksum256, file: String },
Local { sha256: Checksum256 },
}
#[derive(Default)]
pub struct PackageList {
packages: HashMap<String, HashMap<String, (Meta, PackageOrigin)>>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
struct InstalledEdge {
node: InstalledPackageInfo,
}
#[allow(non_snake_case)]
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
struct NextPageInfo {
hasNextPage: bool,
endCursor: String,
}
#[allow(non_snake_case)]
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
struct InstalledConnection {
pageInfo: NextPageInfo,
edges: Vec<InstalledEdge>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
struct InstalledQuery {
installed: InstalledConnection,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
struct LocalPackageEdge {
node: LocalPackageInfo,
}
#[allow(non_snake_case)]
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
struct LocalPackageConnection {
pageInfo: NextPageInfo,
edges: Vec<LocalPackageEdge>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
struct LocalPackageQuery {
installed: LocalPackageConnection,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
struct PackagesEdge {
node: PackageInfo,
}
#[allow(non_snake_case)]
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
struct PackagesConnection {
pageInfo: NextPageInfo,
edges: Vec<PackagesEdge>,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
struct PackagesQuery {
packages: PackagesConnection,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
struct SourcesQuery {
sources: Vec<packages::PackageSource>,
}
#[cfg(not(target_family = "wasm"))]
pub async fn get_package_sources(
base_url: &reqwest::Url,
client: &mut reqwest::Client,
account: AccountNumber,
) -> Result<Vec<packages::PackageSource>, anyhow::Error> {
let result: SourcesQuery = crate::gql_query(
base_url,
client,
packages::SERVICE,
format!(
"query {{ sources(account: {}) {{ url account }} }}",
serde_json::to_string(&account)?
),
)
.await?;
Ok(result.sources)
}
#[cfg(not(target_family = "wasm"))]
pub async fn get_installed_manifest(
base_url: &reqwest::Url,
client: &mut reqwest::Client,
package: &str,
owner: AccountNumber,
) -> Result<PackageManifest, anyhow::Error> {
let url = packages::SERVICE
.url(base_url)?
.join(&format!("/manifest?package={}&owner={}", package, owner))?;
crate::as_json(client.get(url)).await
}
#[cfg(not(target_family = "wasm"))]
pub async fn get_local_manifest(
base_url: &reqwest::Url,
client: &mut reqwest::Client,
sha256: &Checksum256,
) -> Result<PackageManifest, anyhow::Error> {
let url = x_packages::SERVICE
.url(base_url)?
.join(&format!("/manifest/{}", sha256))?;
crate::as_json(client.get(url)).await
}
#[cfg(not(target_family = "wasm"))]
pub async fn get_manifest<T: PackageRegistry + ?Sized>(
reg: &T,
base_url: &reqwest::Url,
client: &mut reqwest::Client,
package: &Meta,
origin: &PackageOrigin,
) -> Result<PackageManifest, anyhow::Error> {
match origin {
PackageOrigin::Installed { owner } => {
get_installed_manifest(base_url, client, &package.name, *owner).await
}
PackageOrigin::Repo { sha256, file } => {
let package = reg
.get_by_info(&package.info(sha256.clone(), file.clone()))
.await?;
Ok(package.manifest())
}
PackageOrigin::Local { sha256 } => get_local_manifest(base_url, client, sha256).await,
}
}
fn max_version(versions: &HashMap<String, (Meta, PackageOrigin)>) -> Result<&str, anyhow::Error> {
let mut iter = versions.keys();
let mut result = iter.next().ok_or_else(|| anyhow!("No version"))?;
for version in iter {
if Version::new(&result)? < Version::new(&version)? {
result = version
}
}
Ok(&*result)
}
fn check_destination(packages: &Vec<PackageOp>, local: bool) -> Result<(), anyhow::Error> {
for package in packages {
match package {
PackageOp::Install(info) | PackageOp::Replace(_, info) => {
match (info.is_local(), local) {
(Some(true), false) => {
Err(anyhow!(
"The package you are installing, or one of its dependencies ({}), is a local package. Local packages must be installed with the `--local` flag.",
&info.name
))?
}
(Some(false), true) => {
Err(anyhow!(
"The package you are installing, or one of its dependencies ({}), is not a local package. Remove the `--local` flag to install this package.",
&info.name
))?
}
_ => {}
}
}
PackageOp::Remove(_) => {}
}
}
Ok(())
}
impl PackageList {
pub fn new() -> PackageList {
PackageList {
packages: HashMap::new(),
}
}
#[cfg(not(target_family = "wasm"))]
pub async fn installed(
base_url: &reqwest::Url,
client: &mut reqwest::Client,
) -> Result<Self, anyhow::Error> {
let mut end_cursor: Option<String> = None;
let mut result = PackageList::new();
loop {
let data = crate::gql_query::<InstalledQuery>(base_url, client, packages::SERVICE,
format!("query {{ installed(first: 100, after: {}) {{ pageInfo {{ hasNextPage endCursor }} edges {{ node {{ name version description depends {{ name version }} accounts services exports {{ name service }} owner }} }} }} }}", serde_json::to_string(&end_cursor)?))
.await.with_context(|| "Failed to list installed packages")?;
for edge in data.installed.edges {
result.insert_installed(edge.node);
}
if !data.installed.pageInfo.hasNextPage {
break;
}
end_cursor = Some(data.installed.pageInfo.endCursor);
}
Ok(result)
}
#[cfg(not(target_family = "wasm"))]
pub async fn local_installed(
base_url: &reqwest::Url,
client: &mut reqwest::Client,
) -> Result<Self, anyhow::Error> {
let mut end_cursor: Option<String> = None;
let mut result = PackageList::new();
loop {
let data = crate::gql_query::<LocalPackageQuery>(base_url, client, x_packages::SERVICE,
format!("query {{ installed(first: 100, after: {}) {{ pageInfo {{ hasNextPage endCursor }} edges {{ node {{ name version description depends {{ name version }} accounts services exports {{ name service }} sha256 }} }} }} }}", serde_json::to_string(&end_cursor)?))
.await.with_context(|| "Failed to list installed packages")?;
for edge in data.installed.edges {
result.insert_local(edge.node);
}
if !data.installed.pageInfo.hasNextPage {
break;
}
end_cursor = Some(data.installed.pageInfo.endCursor);
}
Ok(result)
}
pub fn from_registry<T: PackageRegistry + ?Sized>(reg: &T) -> Result<Self, anyhow::Error> {
let mut result = PackageList::new();
for package in reg.index()? {
result.insert_info(package);
}
Ok(result)
}
pub fn insert(&mut self, meta: Meta, origin: PackageOrigin) {
let name = meta.name.clone();
let version = meta.version.clone();
self.packages
.entry(name)
.or_insert(HashMap::new())
.insert(version, (meta, origin));
}
pub fn insert_info(&mut self, info: PackageInfo) {
self.insert(
info.meta(),
PackageOrigin::Repo {
sha256: info.sha256.clone(),
file: info.file.clone(),
},
);
}
pub fn insert_installed(&mut self, info: InstalledPackageInfo) {
self.insert(info.meta(), PackageOrigin::Installed { owner: info.owner });
}
pub fn insert_local(&mut self, info: LocalPackageInfo) {
self.insert(
info.meta(),
PackageOrigin::Local {
sha256: info.sha256,
},
)
}
pub fn remove_all_versions(&mut self, name: &str) {
self.packages.remove(name);
}
pub fn contains_package(&self, name: &str) -> bool {
self.packages.get(name).is_some()
}
fn contains_version(&self, name: &str, version: &str) -> bool {
if let Some(packages) = self.packages.get(name) {
return packages.contains_key(version);
}
return false;
}
fn as_upgradable(&self) -> Vec<(Meta, PackageDisposition)> {
let mut result = vec![];
for (_, versions) in &self.packages {
for (version, (meta, _)) in versions {
result.push((meta.clone(), PackageDisposition::upgradable(version)));
}
}
result
}
pub async fn resolve_changes<T: PackageRegistry + ?Sized>(
&self,
reg: &T,
packages: &[String],
reinstall: bool,
local: bool,
) -> Result<Vec<PackageOp>, anyhow::Error> {
let index = reg.index()?;
let result = solve_dependencies(
index,
make_refs(packages)?,
self.as_upgradable(),
reinstall,
PackagePreference::Latest,
PackagePreference::Current,
)?;
check_destination(&result, local)?;
Ok(result)
}
pub async fn resolve_upgrade<T: PackageRegistry + ?Sized>(
&self,
reg: &T,
packages: &[String],
pref: PackagePreference,
local: bool,
) -> Result<Vec<PackageOp>, anyhow::Error> {
let index = reg.index()?;
let result = solve_dependencies(
index,
make_refs(packages)?,
self.as_upgradable(),
false,
pref,
if packages.is_empty() {
pref
} else {
PackagePreference::Current
},
)?;
check_destination(&result, local)?;
Ok(result)
}
pub fn into_info(self) -> Vec<(Meta, PackageOrigin)> {
let mut result = vec![];
for (_, versions) in self.packages {
for (_, item) in versions {
result.push(item);
}
}
result.sort_unstable_by(|lhs, rhs| {
(&lhs.0.name, &lhs.0.version).cmp(&(&rhs.0.name, &rhs.0.version))
});
result
}
pub fn into_updated<R: Read + Seek>(
mut self,
ops: &Vec<PackageOpFull<R>>,
owner: AccountNumber,
) -> Self {
for op in ops {
match op {
PackageOpFull::Install(package) => {
self.insert(package.meta().clone(), PackageOrigin::Installed { owner });
}
PackageOpFull::Replace(old, package) => {
self.packages.remove(&old.name);
self.insert(package.meta().clone(), PackageOrigin::Installed { owner });
}
PackageOpFull::Remove(meta) => {
self.packages.remove(&meta.name);
}
}
}
self
}
pub fn get_by_ref(
&self,
package: &PackageRef,
) -> Result<Option<&(Meta, PackageOrigin)>, anyhow::Error> {
if let Some(versions) = self.packages.get(&package.name) {
let mut found: Option<&(Meta, PackageOrigin)> = None;
for (version, item) in versions {
if version_match(&package.version, version)? {
if found.map_or(Ok::<bool, anyhow::Error>(true), |prev| {
Ok(Version::new(&prev.0.version)? < Version::new(version)?)
})? {
found = Some(item)
}
}
}
Ok(found)
} else {
Ok(None)
}
}
pub fn get_by_name(
&self,
package: &str,
) -> Result<Option<&(Meta, PackageOrigin)>, anyhow::Error> {
self.get_by_ref(&make_ref(package)?)
}
pub fn max_versions(&self) -> Result<Vec<(&str, &str)>, anyhow::Error> {
let mut result = Vec::new();
for (name, versions) in &self.packages {
result.push((name.as_str(), max_version(versions)?));
}
result.sort_unstable();
Ok(result)
}
pub fn get_update(&self, package: &str, version: &str) -> Result<Option<&str>, anyhow::Error> {
Ok(if let Some(versions) = self.packages.get(package) {
let best = max_version(versions)?;
if Version::new(version)? < Version::new(best)? {
Some(best)
} else {
None
}
} else {
None
})
}
}