refactor: purge CHandle from module internals (M14 R5)
Module-internal object references are Rust types now (values, Arc, Mutex); CHandle remains only at the oakengine C-ABI boundary: - oakundo: the global stack holds UndoStack/UndoCommand values directly (stack token is the static's address) - oaktimeline: marker/workarea boxes carry Arc<Mutex<T>>; commands share the same allocation through Arc clones (readers in oakengine stubs and the app's graphops updated to lock) - oaktask/oakstorage: sessions, write-through bindings and the database backend pass ProjectArc; the Session drops its manual release bookkeeping; nodeutil keeps the CHandle<->Arc boundary conversion (release_project restored for the app) - oakcodec: handle.rs deleted outright (no facade entry needed it); texture/block placeholders are unit structs - oakrender: copier's project handle is an identity u64; alive-count machinery removed; handle.rs is make_owned/get/get_mut only - oakplugin: the instance registry is gone (its unregister key never matched, leaking weak entries); handle.rs is the RefBox boundary type - oaknode/oakcommon: only dead guard/borrow helpers removed; external payload handles (texture/processor) documented as the boundary Flake hunts landed along the way: the audio recording test serializes on the shared manager lock with a normalized state; the autocacher cancel test uses a slow producer so cancellation is deterministic.
This commit is contained in:
@@ -78,6 +78,7 @@ use oaknode::project::Project;
|
||||
use crate::backend::{LoadResult, StorageBackend};
|
||||
use crate::error::{Error, Result};
|
||||
use crate::handle::CHandle;
|
||||
use crate::nodeutil::ProjectArc;
|
||||
use crate::uri::StorageUri;
|
||||
|
||||
/// Journal kind for redo commands (the D1 save path).
|
||||
@@ -613,15 +614,9 @@ impl DatabaseBackend {
|
||||
if file_uri.scheme != "file" {
|
||||
return Err(Error::Invalid);
|
||||
}
|
||||
let handle = self.load_handle_by_uuid(uri, uuid)?;
|
||||
let project = self.load_project_by_uuid(uri, uuid)?;
|
||||
let backend = crate::backends::ove_xml::OveXmlBackend::new();
|
||||
let result = backend.save(handle, file_uri, 0);
|
||||
// The loaded handle is ours (refcount 1); release it regardless
|
||||
// of the save outcome.
|
||||
if let Some(release) = handle.release {
|
||||
unsafe { release(handle.ctx) };
|
||||
}
|
||||
result
|
||||
backend.save_project(&project, file_uri, 0)
|
||||
}
|
||||
|
||||
/// Import a `.ove`/`.otio`/`.fcpxml` file as a new library row
|
||||
@@ -634,6 +629,9 @@ impl DatabaseBackend {
|
||||
return Err(Error::Invalid);
|
||||
}
|
||||
let backend = crate::registry::Registry::global().resolve(file_uri)?;
|
||||
// The file backend's `load` returns its project as a handle (the
|
||||
// facade-facing trait form); convert it to the boxed project the
|
||||
// crate uses internally, and release the temporary handle.
|
||||
let result = backend.load(file_uri)?;
|
||||
let handle = result.project;
|
||||
if handle.is_null() {
|
||||
@@ -643,12 +641,15 @@ impl DatabaseBackend {
|
||||
)));
|
||||
}
|
||||
let uuid = {
|
||||
let arc = unsafe { crate::nodeutil::project_arc(&handle)? };
|
||||
let fresh = new_uuid();
|
||||
arc.lock().map_err(|_| Error::State)?.uuid = fresh.clone();
|
||||
unsafe { crate::nodeutil::project_arc(&handle)? }
|
||||
.lock()
|
||||
.map_err(|_| Error::State)?
|
||||
.uuid = fresh.clone();
|
||||
fresh
|
||||
};
|
||||
let outcome = self.save(handle, uri, 0).map(|()| uuid.clone());
|
||||
let arc = unsafe { crate::nodeutil::project_arc(&handle)? };
|
||||
let outcome = self.save_project(&arc, uri, 0).map(|()| uuid.clone());
|
||||
if let Some(release) = handle.release {
|
||||
unsafe { release(handle.ctx) };
|
||||
}
|
||||
@@ -683,11 +684,14 @@ impl DatabaseBackend {
|
||||
/// persistent undo history (plan §0): a snapshot at or before `seq`
|
||||
/// is replayed forward with the journal rows up to `seq`. `seq` 0 is
|
||||
/// the empty project. E_INVALID when `seq` is out of range.
|
||||
///
|
||||
/// Returns the project as an owned oaknode handle (the facade-facing
|
||||
/// form — the engine's integration tests consume it this way).
|
||||
pub fn load_at(&self, uri: &StorageUri, uuid: &str, seq: i64) -> Result<CHandle> {
|
||||
let target = parse_target(uri)?;
|
||||
let key = db_key_of(&target);
|
||||
let uuid = uuid.to_string();
|
||||
self.run(key, move |conn| async move {
|
||||
let project = self.run(key, move |conn| async move {
|
||||
let model = project::Entity::find()
|
||||
.filter(project::Column::Uuid.eq(&uuid))
|
||||
.one(&conn)
|
||||
@@ -698,30 +702,22 @@ impl DatabaseBackend {
|
||||
return Err(Error::Invalid);
|
||||
}
|
||||
let xml = assemble_at(&conn, model.id, &model.uuid, seq).await?;
|
||||
Ok(crate::nodeutil::make_project_owned(
|
||||
crate::nodeutil::serializer_load(&xml)?,
|
||||
))
|
||||
})
|
||||
crate::nodeutil::serializer_load(&xml)
|
||||
})?;
|
||||
Ok(crate::nodeutil::make_project_owned(project))
|
||||
}
|
||||
|
||||
/// The manager stats of a library project (plan §4): the head state
|
||||
/// is replayed and the stats derived from the node graph.
|
||||
pub fn project_stats(&self, uri: &StorageUri, uuid: &str) -> Result<ProjectStats> {
|
||||
let handle = self.load_handle_by_uuid(uri, uuid)?;
|
||||
let stats = (|| -> Result<ProjectStats> {
|
||||
let arc = unsafe { crate::nodeutil::project_arc(&handle)? };
|
||||
let guard = arc.lock().map_err(|_| Error::State)?;
|
||||
Ok(derive_stats(&guard))
|
||||
})();
|
||||
if let Some(release) = handle.release {
|
||||
unsafe { release(handle.ctx) };
|
||||
}
|
||||
stats
|
||||
let project = self.load_project_by_uuid(uri, uuid)?;
|
||||
let guard = project.lock().map_err(|_| Error::State)?;
|
||||
Ok(derive_stats(&guard))
|
||||
}
|
||||
|
||||
/// Load the project payload of the library row `uuid` as an owned
|
||||
/// handle (the head state).
|
||||
fn load_handle_by_uuid(&self, uri: &StorageUri, uuid: &str) -> Result<CHandle> {
|
||||
/// Load the project payload of the library row `uuid` as the boxed
|
||||
/// project (the head state).
|
||||
fn load_project_by_uuid(&self, uri: &StorageUri, uuid: &str) -> Result<ProjectArc> {
|
||||
let target = parse_target(uri)?;
|
||||
let key = db_key_of(&target);
|
||||
let uuid = uuid.to_string();
|
||||
@@ -733,11 +729,50 @@ impl DatabaseBackend {
|
||||
.map_err(db_err)?
|
||||
.ok_or(Error::NotFound)?;
|
||||
let xml = assemble_at(&conn, model.id, &model.uuid, model.command_seq).await?;
|
||||
Ok(crate::nodeutil::make_project_owned(
|
||||
crate::nodeutil::serializer_load(&xml)?,
|
||||
))
|
||||
crate::nodeutil::serializer_load(&xml)
|
||||
})
|
||||
}
|
||||
|
||||
/// Load the head state of the library's selected project (the
|
||||
/// `?project=` uuid, or the most recently modified row) as the boxed
|
||||
/// project. The Rust-typed inner load: the facade-facing trait `load`
|
||||
/// wraps the result in an owned handle.
|
||||
pub fn load_project(&self, uri: &StorageUri) -> Result<ProjectArc> {
|
||||
let target = parse_target(uri)?;
|
||||
let key = db_key_of(&target);
|
||||
let project = target.project().map(str::to_string);
|
||||
self.run(key, move |conn| async move {
|
||||
let model = pick_project(&conn, project.as_deref()).await?;
|
||||
let xml = assemble_at(&conn, model.id, &model.uuid, model.command_seq).await?;
|
||||
crate::nodeutil::serializer_load(&xml)
|
||||
})
|
||||
}
|
||||
|
||||
/// Save a project (already read out of its handle) to the library,
|
||||
/// journaling the diff. The Rust-typed inner save: the facade-facing
|
||||
/// trait `save` converts the project handle and forwards here.
|
||||
pub fn save_project(
|
||||
&self,
|
||||
project: &ProjectArc,
|
||||
uri: &StorageUri,
|
||||
_options: u32,
|
||||
) -> Result<()> {
|
||||
let target = parse_target(uri)?;
|
||||
let key = db_key_of(&target);
|
||||
// Serialize under the project lock (the same per-node writer the
|
||||
// `.ove` backend uses — one serialization truth).
|
||||
let (uuid, name, nodes, settings_xml, settings_map) = {
|
||||
let guard = project.lock().map_err(|_| Error::State)?;
|
||||
let uuid = guard.uuid.clone();
|
||||
let name = project_display_name(&guard);
|
||||
let (nodes, settings_xml, settings_map) = serialize_project_state(&guard)?;
|
||||
(uuid, name, nodes, settings_xml, settings_map)
|
||||
};
|
||||
self.run(key, move |conn| async move {
|
||||
save_tx(&conn, &uuid, &name, &nodes, &settings_xml, &settings_map).await
|
||||
})?;
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
impl Default for DatabaseBackend {
|
||||
@@ -763,35 +798,17 @@ impl StorageBackend for DatabaseBackend {
|
||||
}
|
||||
|
||||
fn load(&self, uri: &StorageUri) -> Result<LoadResult> {
|
||||
let target = parse_target(uri)?;
|
||||
let key = db_key_of(&target);
|
||||
let project = target.project().map(str::to_string);
|
||||
self.run(key, move |conn| async move {
|
||||
let model = pick_project(&conn, project.as_deref()).await?;
|
||||
let xml = assemble_at(&conn, model.id, &model.uuid, model.command_seq).await?;
|
||||
let handle =
|
||||
crate::nodeutil::make_project_owned(crate::nodeutil::serializer_load(&xml)?);
|
||||
Ok(LoadResult::success(handle))
|
||||
})
|
||||
// Facade boundary: box the loaded project into an owned handle.
|
||||
Ok(LoadResult::success(crate::nodeutil::make_project_owned(
|
||||
self.load_project(uri)?,
|
||||
)))
|
||||
}
|
||||
|
||||
fn save(&self, project: CHandle, uri: &StorageUri, _options: u32) -> Result<()> {
|
||||
let target = parse_target(uri)?;
|
||||
let key = db_key_of(&target);
|
||||
// Serialize under the project lock (the same per-node writer the
|
||||
// `.ove` backend uses — one serialization truth).
|
||||
fn save(&self, project: CHandle, uri: &StorageUri, options: u32) -> Result<()> {
|
||||
// Facade boundary: convert the project handle to the boxed
|
||||
// project, then run the Rust-typed save.
|
||||
let arc = unsafe { crate::nodeutil::project_arc(&project)? };
|
||||
let (uuid, name, nodes, settings_xml, settings_map) = {
|
||||
let guard = arc.lock().map_err(|_| Error::State)?;
|
||||
let uuid = guard.uuid.clone();
|
||||
let name = project_display_name(&guard);
|
||||
let (nodes, settings_xml, settings_map) = serialize_project_state(&guard)?;
|
||||
(uuid, name, nodes, settings_xml, settings_map)
|
||||
};
|
||||
self.run(key, move |conn| async move {
|
||||
save_tx(&conn, &uuid, &name, &nodes, &settings_xml, &settings_map).await
|
||||
})?;
|
||||
Ok(())
|
||||
self.save_project(&arc, uri, options)
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -67,6 +67,7 @@ use oaknode::track::{TrackBehavior, TrackListBehavior, TrackType};
|
||||
|
||||
use crate::backend::LoadResult;
|
||||
use crate::nodeutil as node;
|
||||
use crate::nodeutil::ProjectArc;
|
||||
use crate::error::{Error, Result};
|
||||
use crate::uri::StorageUri;
|
||||
|
||||
@@ -81,6 +82,46 @@ impl OtioBackend {
|
||||
pub fn new() -> Self {
|
||||
OtioBackend
|
||||
}
|
||||
|
||||
/// Save a project (already read out of its handle) to the URI. The
|
||||
/// Rust-typed inner path: the facade-facing trait `save` converts the
|
||||
/// project handle and forwards here.
|
||||
pub fn save_project(
|
||||
&self,
|
||||
project: &ProjectArc,
|
||||
uri: &StorageUri,
|
||||
_options: u32,
|
||||
) -> Result<()> {
|
||||
let path = uri.local_path().ok_or(Error::Invalid)?.to_string();
|
||||
let ext = uri.extension().ok_or(Error::Invalid)?;
|
||||
let guard = project.lock().map_err(|_| Error::State)?;
|
||||
let timelines = project_to_timelines(&guard);
|
||||
|
||||
match ext.as_str() {
|
||||
"otio" => {
|
||||
let root = if timelines.len() == 1 {
|
||||
Serializable::Timeline(timelines.into_iter().next().unwrap())
|
||||
} else if timelines.is_empty() {
|
||||
// Nothing to export; a single empty timeline is the
|
||||
// friendliest shape for a fresh import.
|
||||
Serializable::Timeline(Timeline::new("Timeline"))
|
||||
} else {
|
||||
let children: Vec<Serializable> = timelines
|
||||
.into_iter()
|
||||
.map(Serializable::Timeline)
|
||||
.collect();
|
||||
Serializable::SerializableCollection(SerializableCollection::new(
|
||||
"oak",
|
||||
children,
|
||||
))
|
||||
};
|
||||
root.to_json_file(&path).map_err(|e| Error::Io(e.to_string()))
|
||||
}
|
||||
"fcpxml" => oakotio::to_fcpxml_file(&timelines, &path)
|
||||
.map_err(|e| Error::Io(e.to_string())),
|
||||
_ => Err(Error::Invalid),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl Default for OtioBackend {
|
||||
@@ -149,38 +190,12 @@ impl crate::backend::StorageBackend for OtioBackend {
|
||||
&self,
|
||||
project: crate::handle::CHandle,
|
||||
uri: &StorageUri,
|
||||
_options: u32,
|
||||
options: u32,
|
||||
) -> Result<()> {
|
||||
let path = uri.local_path().ok_or(Error::Invalid)?.to_string();
|
||||
let ext = uri.extension().ok_or(Error::Invalid)?;
|
||||
// Facade boundary: convert the project handle to the boxed
|
||||
// project, then run the Rust-typed save.
|
||||
let arc = unsafe { node::project_arc(&project)? };
|
||||
let guard = arc.lock().map_err(|_| Error::State)?;
|
||||
let timelines = project_to_timelines(&guard);
|
||||
|
||||
match ext.as_str() {
|
||||
"otio" => {
|
||||
let root = if timelines.len() == 1 {
|
||||
Serializable::Timeline(timelines.into_iter().next().unwrap())
|
||||
} else if timelines.is_empty() {
|
||||
// Nothing to export; a single empty timeline is the
|
||||
// friendliest shape for a fresh import.
|
||||
Serializable::Timeline(Timeline::new("Timeline"))
|
||||
} else {
|
||||
let children: Vec<Serializable> = timelines
|
||||
.into_iter()
|
||||
.map(Serializable::Timeline)
|
||||
.collect();
|
||||
Serializable::SerializableCollection(SerializableCollection::new(
|
||||
"oak",
|
||||
children,
|
||||
))
|
||||
};
|
||||
root.to_json_file(&path).map_err(|e| Error::Io(e.to_string()))
|
||||
}
|
||||
"fcpxml" => oakotio::to_fcpxml_file(&timelines, &path)
|
||||
.map_err(|e| Error::Io(e.to_string())),
|
||||
_ => Err(Error::Invalid),
|
||||
}
|
||||
self.save_project(&arc, uri, options)
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -32,6 +32,7 @@
|
||||
|
||||
use crate::backend::LoadResult;
|
||||
use crate::error::{Error, OAKSTORAGE_OK, OAKSTORAGE_TOO_NEW, OAKSTORAGE_TOO_OLD, OAKSTORAGE_UNKNOWN_VERSION};
|
||||
use crate::nodeutil::ProjectArc;
|
||||
use crate::uri::StorageUri;
|
||||
use oaknode::serializer::XmlRead;
|
||||
|
||||
@@ -82,6 +83,29 @@ impl OveXmlBackend {
|
||||
pub fn new() -> Self {
|
||||
OveXmlBackend
|
||||
}
|
||||
|
||||
/// Save a project (already read out of its handle) to the URI. The
|
||||
/// Rust-typed inner path: the facade-facing trait `save` converts the
|
||||
/// project handle and forwards here.
|
||||
pub fn save_project(
|
||||
&self,
|
||||
project: &ProjectArc,
|
||||
uri: &StorageUri,
|
||||
_options: u32,
|
||||
) -> crate::error::Result<()> {
|
||||
let path = uri
|
||||
.local_path()
|
||||
.ok_or(Error::Invalid)?
|
||||
.to_string();
|
||||
let xml = {
|
||||
let guard = project
|
||||
.lock()
|
||||
.map_err(|_| Error::State)?;
|
||||
crate::nodeutil::serializer_save(&guard)?
|
||||
};
|
||||
std::fs::write(&path, xml).map_err(|e| Error::Io(e.to_string()))?;
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
impl Default for OveXmlBackend {
|
||||
@@ -135,20 +159,11 @@ impl crate::backend::StorageBackend for OveXmlBackend {
|
||||
&self,
|
||||
project: crate::handle::CHandle,
|
||||
uri: &StorageUri,
|
||||
_options: u32,
|
||||
options: u32,
|
||||
) -> crate::error::Result<()> {
|
||||
let path = uri
|
||||
.local_path()
|
||||
.ok_or(Error::Invalid)?
|
||||
.to_string();
|
||||
// Facade boundary: convert the project handle to the boxed
|
||||
// project, then run the Rust-typed save.
|
||||
let arc = unsafe { crate::nodeutil::project_arc(&project)? };
|
||||
let xml = {
|
||||
let guard = arc
|
||||
.lock()
|
||||
.map_err(|_| Error::State)?;
|
||||
crate::nodeutil::serializer_save(&guard)?
|
||||
};
|
||||
std::fs::write(&path, xml).map_err(|e| Error::Io(e.to_string()))?;
|
||||
Ok(())
|
||||
self.save_project(&arc, uri, options)
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user