///|
priv struct FrameworkProcessConfig {
version : Int
manifest : Json
base_dir : String?
ipc : @ipc_ws.WsIpcLaunchConfig?
op_names : Array[String]
extensions : Array[@ipc.IpcExtensionDescriptor]
framework_extension_ids : Array[String]
} derive(ToJson, FromJson)
///|
fn write_framework_process_ipc_config(
path : String,
manifest : @manifest.AppManifest,
ipc_config : FrameworkIpcLaunchConfig,
commands : @proton_command.AppCommandsConfig,
base_dir? : String? = None,
extension_registry? : ExtensionRegistry = ExtensionRegistry::new(),
) -> Result[Unit, String] {
match validate_app_commands_config(commands) {
Err(error) => return Err(error)
Ok(_) => ()
}
match
validate_framework_manifest_extensions(
manifest, extension_registry, commands,
) {
Err(error) => return Err(error)
Ok(_) => ()
}
let config = FrameworkProcessConfig::{
version: framework_config_version,
manifest: @bootstrap.app_manifest_to_json(manifest),
base_dir,
ipc: Some(framework_ipc_launch_config_ws(ipc_config)),
op_names: commands.op_names(),
extensions: commands.extensions(),
framework_extension_ids: commands.framework_extension_ids(),
}
@mbfs.create_dir("target") catch {
_ => ()
}
try {
@mbfs.write_string_to_file(
path,
ToJson::to_json(config).stringify(indent=2),
)
Ok(())
} catch {
err => Err(@debug.render(@debug.to_repr(err)))
}
}
///|
fn default_framework_process_config_path(
ipc_config : FrameworkIpcLaunchConfig,
) -> String {
let ws = framework_ipc_launch_config_ws(ipc_config)
"target/proton-framework-" + ws.token + ".json"
}
///|
fn framework_launch_args(
framework_args : Array[String],
config_path : String,
) -> Array[String] {
let args = framework_args.copy()
args.push(framework_config_arg_name)
args.push(config_path)
args
}
///|
fn validate_framework_process_config(
config : FrameworkProcessConfig,
) -> Result[Unit, String] {
guard config.version == framework_config_version else {
return Err(
"unsupported framework config version: " + config.version.to_string(),
)
}
guard config.manifest is Object(_) else {
return Err("framework config manifest must be an object")
}
guard config.ipc is Some(_) else {
return Err("framework config ipc must be present")
}
match
validate_app_commands_config(
app_commands_config_from_framework_config(config),
) {
Err(error) => Err("invalid framework config commands: " + error)
Ok(_) => Ok(())
}
}
///|
fn app_commands_config_from_framework_config(
config : FrameworkProcessConfig,
) -> @proton_command.AppCommandsConfig {
@proton_command.AppCommandsConfig::from_ipc_descriptors(
config.op_names,
config.extensions,
config.framework_extension_ids,
)
}
///|
fn read_framework_config(
path : String,
) -> Result[FrameworkProcessConfig, String] {
let text = Ok(@mbfs.read_file_to_string(path)) catch {
err => Err(@debug.render(@debug.to_repr(err)))
}
text.bind(fn(text) {
try @json.parse(text) catch {
err => Err(err.to_string())
} noraise {
json =>
try @json.from_json(json) catch {
err => Err(err.to_string())
} noraise {
config => Ok(config)
}
}
})
}
///|
fn framework_config_path_from_env_or_args() -> Result[String, String] {
framework_config_path(
@sys.get_cli_args(),
@sys.get_env_var(framework_config_env_name),
)
}
///|
fn framework_config_path_from_args(
args : Array[String],
) -> Result[String?, String] {
let mut index = 0
let mut matched : String? = None
while index < args.length() {
if args[index] == framework_config_arg_name {
guard index + 1 < args.length() else {
return Err("missing value for " + framework_config_arg_name)
}
guard matched is None else {
return Err("duplicate value for " + framework_config_arg_name)
}
matched = Some(args[index + 1])
index = index + 2
} else {
index = index + 1
}
}
Ok(matched)
}
///|
fn framework_config_path(
args : Array[String],
env_path : String?,
) -> Result[String, String] {
match framework_config_path_from_args(args) {
Err(error) => Err(error)
Ok(Some(path)) => validate_framework_config_path(path)
Ok(None) =>
match env_path {
Some(path) if path != "" => validate_framework_config_path(path)
_ => Err(missing_framework_config_message())
}
}
}
///|
fn validate_framework_config_path(path : String) -> Result[String, String] {
guard path.trim().to_owned() != "" else {
return Err("framework config path must not be empty")
}
Ok(path)
}
///|
fn missing_framework_config_message() -> String {
"missing framework config; pass " +
framework_config_arg_name +
" or set " +
framework_config_env_name
}