Method open_readonly

atomic-repository/src/repository/mod.rs:463–498

Open an existing repository in read-only mode. This method opens the repository without acquiring a write lock on the database, allowing concurrent read access from multiple processes. It's suitable for read-only operations like `status`, `diff`, `log`, and `change`. Use this method when you only need to query the repository state and don't need to make any modifications. This is especially usef

(path: P)

    /// let status = repo.status(StatusOptions::default())?;
    /// ```
    pub fn open_readonly<P: AsRef<Path>>(path: P) -> Result<Self, RepositoryError> {
        if let Some((working_root, canonical, view)) = sandbox::detect_sandbox(path.as_ref()) {
            return Self::open_sandbox_readonly(working_root, canonical, &view);
        }
        let root = Self::find_root(path.as_ref())?;
        let dot_dir = root.join(DOT_DIR);

        // Open the pristine database in read-only mode
        let pristine = Arc::new(
            Pristine::open_readonly(dot_dir.join("pristine.redb"))
                .map_err(RepositoryError::from)?,
        );

        // Read current view from config or use default
        let current_view =
            Self::read_current_view(&dot_dir).unwrap_or_else(|_| DEFAULT_STACK.to_string());

        let change_store = ChangeStore::new(dot_dir.join("changes"), DEFAULT_CACHE_CAPACITY)
            .map_err(|e| RepositoryError::Database(e.to_string()))?;

        let repository = Self {
            root,
            dot_dir,
            current_view,
            pristine,
            change_store,
            is_sandbox: false,
        };
        if repository.has_pending_deferred_tree_alignment() {
            return Err(RepositoryError::InvalidOperation {
                message: "repository view switch is still completing; retry with a writable repository open"
                    .to_string(),
            });
        }
        Ok(repository)
    }

    /// Open for a short-lived writer, waiting at most `timeout` for an
    /// incompatible process handle to close. Other errors return immediately.