diff --git a/Cargo.lock b/Cargo.lock index dd893f223..8e68f2c2c 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -3017,6 +3017,7 @@ dependencies = [ name = "golem-template-service" version = "0.1.0" dependencies = [ + "anyhow", "async-trait", "console-subscriber", "figment", @@ -3024,6 +3025,7 @@ dependencies = [ "golem-api-grpc", "golem-common", "golem-service-base", + "golem-template-service-base", "golem-wasm-ast", "golem-wasm-rpc 0.0.16", "http 0.2.12", @@ -3040,6 +3042,7 @@ dependencies = [ "serde_json", "sqlx", "tap", + "thiserror", "tokio", "tokio-stream", "tokio-util", @@ -3051,6 +3054,21 @@ dependencies = [ "uuid", ] +[[package]] +name = "golem-template-service-base" +version = "0.1.0" +dependencies = [ + "async-trait", + "golem-api-grpc", + "golem-common", + "golem-service-base", + "golem-wasm-ast", + "http 0.2.11", + "serde", + "thiserror", + "tracing", +] + [[package]] name = "golem-wasm-ast" version = "0.2.1" diff --git a/Cargo.toml b/Cargo.toml index 61ff059ca..c4cd8bd3d 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -8,6 +8,7 @@ members = [ "golem-common", "golem-service-base", "golem-template-compilation-service", + "golem-template-service-base", "golem-template-service", "golem-shard-manager", "golem-worker-executor-base", @@ -67,6 +68,7 @@ futures-util = "0.3.29" golem-wasm-ast = "0.2.1" golem-wasm-rpc = { version = "0.0.16", default-features = false, features = ["host"] } http = "1.0.0" # keep in sync with wasmtime +http_02 = { package = "http", version = "0.2.11" } humantime-serde = "1.1.1" hyper = { version = "1.0.1", features = ["full"] } # keep in sync with wasmtime iso8601-timestamp = "0.2.16" diff --git a/golem-service-base/Cargo.toml b/golem-service-base/Cargo.toml index 440ddd37d..80ccbbc14 100644 --- a/golem-service-base/Cargo.toml +++ b/golem-service-base/Cargo.toml @@ -16,7 +16,7 @@ aws-config = { workspace = true } aws-sdk-s3 = { workspace = true } bigdecimal = "0.4.2" http = { workspace = true } -http_02 = { package = "http", version = "0.2.11" } +http_02 = { workspace = true } hyper = { workspace = true } num-traits = "0.2" poem-openapi = { workspace = true } diff --git a/golem-shard-manager/Cargo.toml b/golem-shard-manager/Cargo.toml index aebd419cd..d765b1ff5 100644 --- a/golem-shard-manager/Cargo.toml +++ b/golem-shard-manager/Cargo.toml @@ -23,7 +23,7 @@ figment = { workspace = true } fred = { workspace = true } futures = { workspace = true } http = { workspace = true } -http_02 = { package = "http", version = "0.2.11" } +http_02 = { workspace = true } humantime-serde = { workspace = true } kube = { version = "0.88.1", features = ["client"], optional = true } k8s-openapi = { version = "0.21.1", features = ["earliest"], optional = true } diff --git a/golem-template-compilation-service/Cargo.toml b/golem-template-compilation-service/Cargo.toml index 1d013842e..109fb7242 100644 --- a/golem-template-compilation-service/Cargo.toml +++ b/golem-template-compilation-service/Cargo.toml @@ -17,7 +17,7 @@ golem-worker-executor-base = { version = "0.0.0", path = "../golem-worker-execut async-trait = { workspace = true } futures = { workspace = true } http = { workspace = true } -http_02 = { package = "http", version = "0.2.11" } +http_02 = { workspace = true } tokio = { workspace = true } tracing = { workspace = true } diff --git a/golem-template-compilation-service/src/config.rs b/golem-template-compilation-service/src/config.rs index 243d4e3c6..979029831 100644 --- a/golem-template-compilation-service/src/config.rs +++ b/golem-template-compilation-service/src/config.rs @@ -51,7 +51,7 @@ impl TemplateServiceConfig { .authority(format!("{}:{}", self.host, self.port).as_str()) .path_and_query("/") .build() - .expect("Failed to build TemplateServiceTemplateService URI") + .expect("Failed to build TemplateService URI") } } diff --git a/golem-template-service-base/Cargo.toml b/golem-template-service-base/Cargo.toml new file mode 100644 index 000000000..72dd3bc5b --- /dev/null +++ b/golem-template-service-base/Cargo.toml @@ -0,0 +1,17 @@ +[package] +name = "golem-template-service-base" +version = "0.1.0" +edition = "2021" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] +async-trait = { workspace = true } +golem-api-grpc = { path = "../golem-api-grpc", version = "0.0.0" } +golem-common = { path = "../golem-common", version = "0.0.0" } +golem-service-base = { path = "../golem-service-base" } +golem-wasm-ast = { workspace = true } +http_02 = { workspace = true } +serde = { workspace = true } +thiserror = { workspace = true } +tracing = { workspace = true } diff --git a/golem-template-service-base/src/config.rs b/golem-template-service-base/src/config.rs new file mode 100644 index 000000000..43c753996 --- /dev/null +++ b/golem-template-service-base/src/config.rs @@ -0,0 +1,27 @@ +use serde::Deserialize; + +#[derive(Clone, Debug, Deserialize)] +#[serde(tag = "type", content = "config")] +#[derive(Default)] +pub enum TemplateCompilationConfig { + Enabled(TemplateCompilationEnabledConfig), + #[default] + Disabled, +} + +#[derive(Clone, Debug, Deserialize)] +pub struct TemplateCompilationEnabledConfig { + pub host: String, + pub port: u16, +} + +impl TemplateCompilationEnabledConfig { + pub fn uri(&self) -> http_02::Uri { + http_02::Uri::builder() + .scheme("http") + .authority(format!("{}:{}", self.host, self.port).as_str()) + .path_and_query("/") + .build() + .expect("Failed to build TemplateCompilationService URI") + } +} diff --git a/golem-template-service-base/src/lib.rs b/golem-template-service-base/src/lib.rs new file mode 100644 index 000000000..11bd8fe24 --- /dev/null +++ b/golem-template-service-base/src/lib.rs @@ -0,0 +1,2 @@ +pub mod config; +pub mod service; diff --git a/golem-template-service-base/src/service/mod.rs b/golem-template-service-base/src/service/mod.rs new file mode 100644 index 000000000..2ee712a8d --- /dev/null +++ b/golem-template-service-base/src/service/mod.rs @@ -0,0 +1,2 @@ +pub mod template_compilation; +pub mod template_processor; diff --git a/golem-template-service/src/service/template_compilation.rs b/golem-template-service-base/src/service/template_compilation.rs similarity index 89% rename from golem-template-service/src/service/template_compilation.rs rename to golem-template-service-base/src/service/template_compilation.rs index 4963a329f..4bd74eecb 100644 --- a/golem-template-service/src/service/template_compilation.rs +++ b/golem-template-service-base/src/service/template_compilation.rs @@ -15,10 +15,7 @@ pub struct TemplateCompilationServiceDefault { } impl TemplateCompilationServiceDefault { - pub fn new(host: String, port: u16) -> Self { - let uri = format!("http://{}:{}", host, port) - .parse() - .expect("Failed to parse TemplateCompilationService URI"); + pub fn new(uri: http_02::Uri) -> Self { Self { uri } } } diff --git a/golem-template-service-base/src/service/template_processor.rs b/golem-template-service-base/src/service/template_processor.rs new file mode 100644 index 000000000..058a0d21d --- /dev/null +++ b/golem-template-service-base/src/service/template_processor.rs @@ -0,0 +1,89 @@ +use std::fmt::{self, Display, Formatter}; + +use golem_service_base::model::TemplateMetadata; +use golem_wasm_ast::{ + analysis::{AnalysedExport, AnalysedFunction, AnalysisContext, AnalysisFailure}, + component::Component, + IgnoreAllButMetadata, +}; + +pub fn process_template(data: &[u8]) -> Result { + let component = Component::::from_bytes(data) + .map_err(TemplateProcessingError::Parsing)?; + + let producers = component + .get_all_producers() + .into_iter() + .map(|producers| producers.into()) + .collect::>(); + + let state = AnalysisContext::new(component); + + let mut exports = state + .get_top_level_exports() + .map_err(TemplateProcessingError::Analysis)?; + + add_resource_drops(&mut exports); + + let exports = exports + .into_iter() + .map(|export| export.into()) + .collect::>(); + + Ok(TemplateMetadata { exports, producers }) +} + +#[derive(Debug, thiserror::Error)] +pub enum TemplateProcessingError { + Parsing(String), + Analysis(AnalysisFailure), +} + +impl Display for TemplateProcessingError { + fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result { + match self { + TemplateProcessingError::Parsing(e) => write!(f, "Parsing error: {}", e), + TemplateProcessingError::Analysis(source) => { + let AnalysisFailure::Failed(error) = source; + write!(f, "Analysis error: {}", error) + } + } + } +} + +fn add_resource_drops(exports: &mut Vec) { + // Components are not exporting explicit drop functions for exported resources, but + // worker executor does. So we keep golem-wasm-ast as an universal library and extend + // its result with the explicit drops here, for each resource, identified by an exported + // constructor. + + let mut to_add = Vec::new(); + for export in exports.iter_mut() { + match export { + AnalysedExport::Function(fun) => { + if fun.is_constructor() { + let drop_name = fun.name.replace("[constructor]", "[drop]"); + to_add.push(AnalysedExport::Function(AnalysedFunction { + name: drop_name, + ..fun.clone() + })); + } + } + AnalysedExport::Instance(instance) => { + let mut to_add = Vec::new(); + for fun in &instance.funcs { + if fun.is_constructor() { + let drop_name = fun.name.replace("[constructor]", "[drop]"); + to_add.push(AnalysedFunction { + name: drop_name, + ..fun.clone() + }); + } + } + instance.funcs.extend(to_add.into_iter()); + } + } + } + + exports.extend(to_add); +} diff --git a/golem-template-service/Cargo.toml b/golem-template-service/Cargo.toml index 9d7a3b8b5..98fb1998f 100644 --- a/golem-template-service/Cargo.toml +++ b/golem-template-service/Cargo.toml @@ -49,4 +49,7 @@ tracing = { workspace = true } tracing-subscriber = { workspace = true } uuid = { workspace = true } humantime-serde = { workspace = true } -http_02 = { package = "http", version = "0.2.11" } +http_02 = { workspace = true } +golem-template-service-base = { version = "0.1.0", path = "../golem-template-service-base" } +thiserror.workspace = true +anyhow.workspace = true diff --git a/golem-template-service/src/api/template.rs b/golem-template-service/src/api/template.rs index c2bfbcec4..ad49d27e9 100644 --- a/golem-template-service/src/api/template.rs +++ b/golem-template-service/src/api/template.rs @@ -51,44 +51,33 @@ pub struct UploadPayload { type Result = std::result::Result; impl From for TemplateError { - fn from(value: TemplateServiceError) -> Self { - match value { - TemplateServiceError::Internal(error) => { - TemplateError::InternalError(Json(ErrorBody { error })) - } - TemplateServiceError::TemplateProcessingError(error) => { - TemplateError::BadRequest(Json(ErrorsBody { - errors: vec![error], - })) - } - TemplateServiceError::UnknownTemplateId(_) => { + fn from(error: TemplateServiceError) -> Self { + match error { + TemplateServiceError::UnknownTemplateId(_) + | TemplateServiceError::UnknownVersionedTemplateId(_) => { TemplateError::NotFound(Json(ErrorBody { - error: "Template not found".to_string(), + error: error.to_string(), })) } - TemplateServiceError::UnknownVersionedTemplateId(_) => { - TemplateError::NotFound(Json(ErrorBody { - error: "Template not found".to_string(), + TemplateServiceError::AlreadyExists(_) => { + TemplateError::AlreadyExists(Json(ErrorBody { + error: error.to_string(), })) } - TemplateServiceError::IOError(error) => { - TemplateError::InternalError(Json(ErrorBody { error })) + TemplateServiceError::Internal(error) => { + TemplateError::InternalError(Json(ErrorBody { + error: error.to_string(), + })) } - TemplateServiceError::AlreadyExists(_) => { - TemplateError::AlreadyExists(Json(ErrorBody { - error: "Template already exists".to_string(), + TemplateServiceError::TemplateProcessingError(error) => { + TemplateError::BadRequest(Json(ErrorsBody { + errors: vec![error.to_string()], })) } } } } -impl From for TemplateError { - fn from(value: String) -> Self { - TemplateError::InternalError(Json(ErrorBody { error: value })) - } -} - impl From for TemplateError { fn from(value: ReadBodyError) -> Self { TemplateError::InternalError(Json(ErrorBody { diff --git a/golem-template-service/src/config.rs b/golem-template-service/src/config.rs index 16bc829b7..23f97236a 100644 --- a/golem-template-service/src/config.rs +++ b/golem-template-service/src/config.rs @@ -15,6 +15,7 @@ use figment::providers::{Env, Format, Toml}; use figment::Figment; use golem_service_base::config::TemplateStoreConfig; +use golem_template_service_base::config::TemplateCompilationConfig; use serde::Deserialize; use std::time::Duration; @@ -49,7 +50,6 @@ pub struct TemplateServiceConfig { pub db: DbConfig, pub template_store: TemplateStoreConfig, pub compilation: TemplateCompilationConfig, - pub worker_executor_client_cache: WorkerExecutorClientCacheConfig, } #[derive(Clone, Debug, Deserialize)] @@ -79,21 +79,6 @@ pub struct DbPostgresConfig { pub schema: Option, } -#[derive(Clone, Debug, Deserialize)] -#[serde(tag = "type", content = "config")] -#[derive(Default)] -pub enum TemplateCompilationConfig { - Enabled(TemplateCompilationEnabledConfig), - #[default] - Disabled, -} - -#[derive(Clone, Debug, Deserialize)] -pub struct TemplateCompilationEnabledConfig { - pub host: String, - pub port: u16, -} - impl TemplateServiceConfig { pub fn new() -> Self { Figment::new() @@ -114,7 +99,6 @@ impl Default for TemplateServiceConfig { db: DbConfig::default(), template_store: TemplateStoreConfig::default(), compilation: TemplateCompilationConfig::default(), - worker_executor_client_cache: WorkerExecutorClientCacheConfig::default(), } } } diff --git a/golem-template-service/src/grpcapi/template.rs b/golem-template-service/src/grpcapi/template.rs index dd926e3ea..fbe36ed6f 100644 --- a/golem-template-service/src/grpcapi/template.rs +++ b/golem-template-service/src/grpcapi/template.rs @@ -39,30 +39,25 @@ use crate::service::template; impl From for TemplateError { fn from(value: template::TemplateError) -> Self { let error = match value { - template::TemplateError::Internal(error) => { - template_error::Error::InternalError(ErrorBody { error }) - } - template::TemplateError::IOError(error) => { - template_error::Error::InternalError(ErrorBody { error }) - } - template::TemplateError::TemplateProcessingError(error) => { - template_error::Error::BadRequest(ErrorsBody { - errors: vec![error], - }) - } template::TemplateError::AlreadyExists(_) => { template_error::Error::AlreadyExists(ErrorBody { - error: "Template already exists".to_string(), + error: value.to_string(), }) } - template::TemplateError::UnknownTemplateId(_) => { + template::TemplateError::UnknownTemplateId(_) + | template::TemplateError::UnknownVersionedTemplateId(_) => { template_error::Error::NotFound(ErrorBody { - error: "Template not found".to_string(), + error: value.to_string(), }) } - template::TemplateError::UnknownVersionedTemplateId(_) => { - template_error::Error::NotFound(ErrorBody { - error: "Template not found".to_string(), + template::TemplateError::TemplateProcessingError(error) => { + template_error::Error::BadRequest(ErrorsBody { + errors: vec![error.to_string()], + }) + } + template::TemplateError::Internal(error) => { + template_error::Error::InternalError(ErrorBody { + error: error.to_string(), }) } }; diff --git a/golem-template-service/src/service.rs b/golem-template-service/src/service.rs index 3114a1582..c822271ef 100644 --- a/golem-template-service/src/service.rs +++ b/golem-template-service/src/service.rs @@ -13,21 +13,24 @@ // limitations under the License. pub mod template; -pub mod template_compilation; use golem_service_base::config::TemplateStoreConfig; use golem_service_base::service::template_object_store; +use golem_template_service_base::config::TemplateCompilationConfig; +use golem_template_service_base::service::template_compilation::{ + TemplateCompilationService, TemplateCompilationServiceDefault, + TemplateCompilationServiceDisabled, +}; use std::sync::Arc; -use crate::config::{DbConfig, TemplateCompilationConfig, TemplateServiceConfig}; +use crate::config::{DbConfig, TemplateServiceConfig}; use crate::db; use crate::repo::template::{DbTemplateRepo, TemplateRepo}; #[derive(Clone)] pub struct Services { pub template_service: Arc, - pub compilation_service: - Arc, + pub compilation_service: Arc, } impl Services { @@ -57,19 +60,13 @@ impl Services { } }; - let compilation_service: Arc< - dyn template_compilation::TemplateCompilationService + Sync + Send, - > = match config.compilation.clone() { - TemplateCompilationConfig::Enabled(config) => Arc::new( - template_compilation::TemplateCompilationServiceDefault::new( - config.host, - config.port, - ), - ), - TemplateCompilationConfig::Disabled => { - Arc::new(template_compilation::TemplateCompilationServiceDisabled) - } - }; + let compilation_service: Arc = + match config.compilation.clone() { + TemplateCompilationConfig::Enabled(config) => { + Arc::new(TemplateCompilationServiceDefault::new(config.uri())) + } + TemplateCompilationConfig::Disabled => Arc::new(TemplateCompilationServiceDisabled), + }; let template_service: Arc = Arc::new(template::TemplateServiceDefault::new( @@ -88,9 +85,8 @@ impl Services { let template_service: Arc = Arc::new(template::TemplateServiceNoOp::default()); - let compilation_service: Arc< - dyn template_compilation::TemplateCompilationService + Sync + Send, - > = Arc::new(template_compilation::TemplateCompilationServiceDisabled); + let compilation_service: Arc = + Arc::new(TemplateCompilationServiceDisabled); Services { template_service, diff --git a/golem-template-service/src/service/template.rs b/golem-template-service/src/service/template.rs index f60863911..081e7679d 100644 --- a/golem-template-service/src/service/template.rs +++ b/golem-template-service/src/service/template.rs @@ -17,61 +17,45 @@ use std::sync::Arc; use async_trait::async_trait; use golem_common::model::TemplateId; -use golem_wasm_ast::analysis::{ - AnalysedExport, AnalysedFunction, AnalysisContext, AnalysisFailure, +use golem_template_service_base::service::template_compilation::TemplateCompilationService; +use golem_template_service_base::service::template_processor::{ + process_template, TemplateProcessingError, }; -use golem_wasm_ast::component::Component; -use golem_wasm_ast::IgnoreAllButMetadata; use tap::TapFallible; use tracing::{error, info}; use crate::repo::template::TemplateRepo; use crate::repo::RepoError; -use crate::service::template_compilation::TemplateCompilationService; use crate::service::template_object_store::TemplateObjectStore; use golem_service_base::model::*; -#[derive(Debug, Clone)] +#[derive(Debug, thiserror::Error)] pub enum TemplateError { + #[error("Template already exists: {0}")] AlreadyExists(TemplateId), + #[error("Unknown template id: {0}")] UnknownTemplateId(TemplateId), + #[error("Unknown versioned template id: {0}")] UnknownVersionedTemplateId(VersionedTemplateId), - Internal(String), - IOError(String), - // TODO: processing error? more detail? - TemplateProcessingError(String), -} - -impl Display for TemplateError { - fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - match *self { - TemplateError::AlreadyExists(ref template_id) => { - write!(f, "Template already exists: {}", template_id) - } - TemplateError::UnknownTemplateId(ref template_id) => { - write!(f, "Unknown template id: {}", template_id) - } - TemplateError::UnknownVersionedTemplateId(ref template_id) => { - write!(f, "Unknown versioned template id: {}", template_id) - } - TemplateError::Internal(ref error) => write!(f, "Internal error: {}", error), - TemplateError::IOError(ref error) => write!(f, "IO error: {}", error), - TemplateError::TemplateProcessingError(ref error) => { - write!(f, "Template processing error: {}", error) - } - } - } + #[error(transparent)] + TemplateProcessingError(#[from] TemplateProcessingError), + #[error("Internal error: {0}")] + Internal(anyhow::Error), } impl TemplateError { - pub fn internal(error: T) -> Self { - TemplateError::Internal(error.to_string()) + fn internal(error: E, context: C) -> Self + where + E: Display + std::fmt::Debug + Send + Sync + 'static, + C: Display + Send + Sync + 'static, + { + TemplateError::Internal(anyhow::Error::msg(error).context(context)) } } impl From for TemplateError { fn from(error: RepoError) -> Self { - TemplateError::internal(error) + TemplateError::Internal(anyhow::Error::msg(error.to_string())) } } @@ -151,7 +135,7 @@ impl TemplateService for TemplateServiceDefault { self.check_new_name(template_name).await?; - let metadata = self.process_template(&data)?; + let metadata = process_template(&data)?; let template_id = TemplateId::new_v4(); @@ -172,9 +156,10 @@ impl TemplateService for TemplateServiceDefault { versioned_template_id.template_id, metadata.exports ); - let template_size: i32 = data.len().try_into().map_err(|e| { - TemplateError::internal(format!("Failed to convert data length: {}", e)) - })?; + let template_size: i32 = data + .len() + .try_into() + .map_err(|e| TemplateError::internal(e, "Failed to convert data length"))?; tokio::try_join!( self.upload_user_template(&user_template_id, data.clone()), @@ -206,7 +191,7 @@ impl TemplateService for TemplateServiceDefault { ) -> Result { info!("Updating template {}", template_id); - let metadata = self.process_template(&data)?; + let metadata = process_template(&data)?; let next_template = self .template_repo @@ -221,9 +206,10 @@ impl TemplateService for TemplateServiceDefault { template_id, next_template.versioned_template_id.version, metadata.exports ); - let template_size: i32 = data.len().try_into().map_err(|e| { - TemplateError::internal(format!("Failed to convert data length: {}", e)) - })?; + let template_size: i32 = data + .len() + .try_into() + .map_err(|e| TemplateError::internal(e, "Failed to convert data length"))?; tokio::try_join!( self.upload_user_template(&next_template.user_template_id, data.clone()), @@ -274,7 +260,7 @@ impl TemplateService for TemplateServiceDefault { .get(&self.get_protected_object_store_key(&id)) .await .tap_err(|e| error!("Error downloading template: {}", e)) - .map_err(|e| TemplateError::IOError(e.to_string())) + .map_err(|e| TemplateError::internal(e.to_string(), "Error downloading template")) } async fn get_protected_data( @@ -321,7 +307,8 @@ impl TemplateService for TemplateServiceDefault { .object_store .get(&object_key) .await - .map_err(|e| TemplateError::internal(e.to_string()))?; + .tap_err(|e| error!("Error retrieving template: {}", e)) + .map_err(|e| TemplateError::internal(e.to_string(), "Error retrieving template"))?; Ok(Some(result)) } @@ -396,74 +383,6 @@ impl TemplateServiceDefault { }) } - fn process_template(&self, data: &[u8]) -> Result { - let component = Component::::from_bytes(data) - .map_err(|e| TemplateError::TemplateProcessingError(e.to_string()))?; - - let producers = component - .get_all_producers() - .into_iter() - .map(|producers| producers.into()) - .collect::>(); - - let state = AnalysisContext::new(component); - - let mut exports = state.get_top_level_exports().map_err(|e| { - TemplateError::TemplateProcessingError(format!( - "Error getting top level exports: {}", - match e { - AnalysisFailure::Failed(e) => e, - } - )) - })?; - - self.add_resource_drops(&mut exports); - - let exports = exports - .into_iter() - .map(|export| export.into()) - .collect::>(); - - Ok(TemplateMetadata { exports, producers }) - } - - fn add_resource_drops(&self, exports: &mut Vec) { - // Components are not exporting explicit drop functions for exported resources, but - // worker executor does. So we keep golem-wasm-ast as an universal library and extend - // its result with the explicit drops here, for each resource, identified by an exported - // constructor. - - let mut to_add = Vec::new(); - for export in exports.iter_mut() { - match export { - AnalysedExport::Function(fun) => { - if fun.is_constructor() { - let drop_name = fun.name.replace("[constructor]", "[drop]"); - to_add.push(AnalysedExport::Function(AnalysedFunction { - name: drop_name, - ..fun.clone() - })); - } - } - AnalysedExport::Instance(instance) => { - let mut to_add = Vec::new(); - for fun in &instance.funcs { - if fun.is_constructor() { - let drop_name = fun.name.replace("[constructor]", "[drop]"); - to_add.push(AnalysedFunction { - name: drop_name, - ..fun.clone() - }); - } - } - instance.funcs.extend(to_add.into_iter()); - } - } - } - - exports.extend(to_add); - } - fn get_user_object_store_key(&self, id: &UserTemplateId) -> String { id.slug() } @@ -482,11 +401,7 @@ impl TemplateServiceDefault { self.object_store .put(&self.get_user_object_store_key(user_template_id), data) .await - .map_err(|e| { - let message = format!("Failed to upload user template: {}", e); - error!("{}", message); - TemplateError::IOError(message) - }) + .map_err(|e| TemplateError::internal(e.to_string(), "Failed to upload user template")) } async fn upload_protected_template( @@ -503,9 +418,7 @@ impl TemplateServiceDefault { ) .await .map_err(|e| { - let message = format!("Failed to upload protected template: {}", e); - error!("{}", message); - TemplateError::IOError(message) + TemplateError::internal(e.to_string(), "Failed to upload protected template") }) } } diff --git a/golem-worker-executor-base/Cargo.toml b/golem-worker-executor-base/Cargo.toml index 662b88818..e96b21ba1 100644 --- a/golem-worker-executor-base/Cargo.toml +++ b/golem-worker-executor-base/Cargo.toml @@ -45,7 +45,7 @@ futures-util = { workspace = true } gethostname = "0.4.3" golem-wit = { version = "0.2.3" } http = { workspace = true } -http_02 = { package = "http", version = "0.2.11" } +http_02 = { workspace = true } http-body = "1.0.0" # keep in sync with wasmtime humantime-serde = { workspace = true } hyper = { workspace = true } diff --git a/golem-worker-service-base/Cargo.toml b/golem-worker-service-base/Cargo.toml index 6b12f5dd8..481945073 100644 --- a/golem-worker-service-base/Cargo.toml +++ b/golem-worker-service-base/Cargo.toml @@ -39,7 +39,7 @@ tonic-health = { workspace = true } tonic-reflection = { workspace = true } figment = { workspace = true } url = { workspace = true } -http_02 = { package = "http", version = "0.2.11" } +http_02 = { workspace = true } hyper = { workspace = true } bytes = { workspace = true } tokio = { workspace = true }