gitpane 1.0.0__py3-none-any.whl

gitpane/controller/refresh_controller.py

@@ -0,0 +1,477 @@
+"""Read a window's repository again when an operation, a timer or the user asks for it."""
+
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass, field, replace
+from enum import Enum
+from typing import TYPE_CHECKING
+
+from PySide6.QtCore import QObject, Signal
+
+from gitpane.config import SharedText
+from gitpane.history.file_history import WindowCapability
+from gitpane.history.repository_value import RequestIdentity
+from gitpane.operation.diagnostic import Diagnostic
+from gitpane.reference.reference_edit import final_reference_snapshot
+from gitpane.system.path_identity import canonical_path
+from gitpane.worktree.worktree_snapshot import SubmoduleState, WorktreeKey
+
+if TYPE_CHECKING:
+    from gitpane.controller.operation_policy import OperationPolicy
+    from gitpane.controller.reference_read_controller import ReferenceReadController
+    from gitpane.controller.session_registry import RepositorySession, SessionRegistry
+    from gitpane.controller.staging_session_registry import StagingSessionRegistry
+    from gitpane.history.repository import GitRepository
+    from gitpane.operation.repository_operation import OperationIntent, OperationOutcome
+    from gitpane.reference.reference_snapshot import ReferenceSnapshot
+    from gitpane.sequencer.rebase_state import RebaseSnapshot
+    from gitpane.sequencer.replay_state import ReplaySnapshot
+    from gitpane.submodule.submodule_discovery import SubmoduleReferenceState, SubmoduleService, SubmoduleSnapshot
+    from gitpane.worktree.staging import StagingSession
+
+
+@dataclass(frozen=True)
+class ReplayRefreshPublication:
+    """The state a Cherry-pick or Revert operation published when it ended, offered to the refresh that shows its result.
+
+    It is display data for that one refresh of that one worktree and Git executable, never a proof for a write, and it
+    is used only while it is still the service's latest state, with no read started since.
+    """
+
+    state: ReplaySnapshot
+    git_filename: str
+
+
+@dataclass(frozen=True)
+class RebaseRefreshPublication:
+    """The state a rebase command published when it ended, offered to the refresh that shows its result.
+
+    It is display data for that one refresh of that one worktree and Git executable, never a proof for a write. It is
+    shown only while it is still the service's latest state with no read started since, and only once the native
+    rebase files are found exactly as the command's own capture proved them.
+    """
+
+    state: RebaseSnapshot
+    git_filename: str
+
+
+# Compared by identity: two entries describing the same worktree are still two different reads.
+@dataclass(eq=False)
+class FullRefreshRead:
+    """The working tree read and the pause state observation that the windows of one worktree share for one refresh.
+
+    One F5, or one operation result that refreshes several windows of the same worktree, reads the working tree once
+    and looks at the rebase and replay state once; every window it registered receives both. It describes reads in
+    progress for display, never a proof for a write, and it is never reused by a later refresh the user asks for:
+    that one starts a new entry and reads again.
+
+    ``staging_generation`` is the read number of the preparation session's read serving this entry. A publication of
+    that read, or of an older one, needs no automatic pause observation of its own, because the entry observes itself;
+    any later read is new information and is observed as usual.
+
+    ``replay_publication`` is the state a Cherry-pick or Revert of this worktree published when it ended: the entry's
+    pause observation shows it instead of reading the replay state again, while it is still the latest one.
+    ``rebase_publication`` does the same for the state a rebase command published.
+    """
+
+    key: WorktreeKey
+    git_filename: str
+    explicit: bool = False
+    session_generation_by_id: dict[str, int] = field(default_factory=dict)
+    worktree_read_requested: bool = False
+    staging_generation: int = 0
+    pause_observed: bool = False
+    read_published: bool = False
+    replay_publication: ReplayRefreshPublication | None = None
+    rebase_publication: RebaseRefreshPublication | None = None
+
+
+class RefreshScope(Enum):
+    """How much of a repository window one refresh reads again.
+
+    A write that only changes references (a tag, a branch left unchecked out, a deletion, a remote rename) leaves the
+    working tree, the rebase state and the submodules as they were, so its windows read references and graph only.
+    """
+
+    FULL = "full"
+    REFERENCES = "references"
+
+
+@dataclass(frozen=True)
+class RefreshRequest:
+    """One refresh a window was asked for, kept as is while an earlier refresh of the same window still runs.
+
+    ``reference_snapshot`` is the final reference capture of the operation that asked for the refresh, already checked
+    to come from this window's own worktree; it is display data, checked again against the reference files before it
+    is shown, and never authorizes a write. ``target_generation`` is the window generation the request was made
+    against: once another generation has started, the capture is dropped and the references are read again.
+    ``full_refresh_read`` is the shared working tree read the caller registered this window in, for the windows one
+    operation result refreshes together; a request without it, such as F5, starts a read of its own.
+    ``outside_already_read`` tells that the working tree and the pause state were read just before this request, which
+    follows what they showed: a moved HEAD then asks for nothing more than references and graph.
+    ``selection_oid`` is a verified replacement for the previously selected commit after a history rewrite; it is
+    applied when this refresh actually starts, including when the request waited behind another read.
+    """
+
+    scope: RefreshScope
+    reference_snapshot: ReferenceSnapshot | None = None
+    source_session_id: str | None = None
+    source_generation: int | None = None
+    target_generation: int = 0
+    recovery: bool = False
+    full_refresh_read: FullRefreshRead | None = field(default=None, compare=False)
+    outside_already_read: bool = False
+    selection_oid: str | None = None
+
+    def merged_with(self, newer: RefreshRequest) -> RefreshRequest:
+        """Combine this waiting request with a newer one: a complete or recovery request wins, the newer capture replaces the older.
+
+        A newer request without a capture, such as F5, therefore drops the capture an operation handed over earlier.
+        The working tree is left unread only when neither request needs it read.
+        """
+        scope = RefreshScope.FULL if RefreshScope.FULL in (self.scope, newer.scope) else RefreshScope.REFERENCES
+        return replace(newer, scope=scope, recovery=self.recovery or newer.recovery, target_generation=self.target_generation,
+                       outside_already_read=self.outside_already_read and newer.outside_already_read, selection_oid=newer.selection_oid or self.selection_oid)
+
+
+class RefreshController(QObject):
+    """The refreshes of every repository window: one running and one waiting per window, the working tree read and the pause observation the windows of one worktree share, the submodule family each window shows."""
+
+    # Asks for a look at the rebase and replay pause state of a window a refresh read: the session id, then the
+    # ReplayRefreshPublication and the RebaseRefreshPublication an ending operation left to show instead of a read, or None.
+    pause_observation_requested = Signal(str, object, object)
+    refresh_started = Signal(str)
+
+    def __init__(self, *, session_registry_controller: SessionRegistry, operation_policy_controller: OperationPolicy, staging_session_registry_controller: StagingSessionRegistry, reference_read_controller: ReferenceReadController,
+                 repository: GitRepository, submodule: SubmoduleService, parent: QObject | None = None) -> None:
+        """Receive the services and the lower controllers a refresh reads through; the wiring builds it once the submodule service exists, and the operations, the timers and the windows ask it for a refresh."""
+        super().__init__(parent)
+        self.session_registry_controller = session_registry_controller
+        self.operation_policy_controller = operation_policy_controller
+        self.staging_session_registry_controller = staging_session_registry_controller
+        self.repository = repository
+        self.reference_read_controller = reference_read_controller
+        self.submodule = submodule
+        # The latest complete refresh of each worktree, which the windows refreshed together share.
+        self.full_refresh_read_by_key: dict[WorktreeKey, FullRefreshRead] = {}
+        self.checkout_refresh_session_set: set[str] = set()
+        self.submodule_snapshot_by_session: dict[str, SubmoduleSnapshot] = {}
+        self.submodule_read_generation_by_session: dict[str, int] = {}
+        self.recovery_request_set: set[RequestIdentity] = set()
+
+    def begin_full_refresh_read(self, key: WorktreeKey, *, explicit: bool = False, published_staging: StagingSession | None = None) -> FullRefreshRead:
+        """Start the entry the windows of one worktree share for one refresh, replacing any older entry of that worktree.
+
+        ``published_staging`` is a preparation session that has just shown the complete read an operation made after
+        writing: that read serves the entry, and the session itself reads again when it cannot, so the entry asks for
+        no working tree read of its own.
+        """
+        shared = FullRefreshRead(key, self.repository.git_filename, explicit)
+        if published_staging is not None:
+            shared.worktree_read_requested = True
+            shared.staging_generation = published_staging.generation
+        self.full_refresh_read_by_key[key] = shared
+        return shared
+
+    def full_refresh_read_for(self, session: RepositorySession, shared_by_key: dict[WorktreeKey, FullRefreshRead], *, explicit: bool = False) -> FullRefreshRead:
+        """Answer the entry one operation result shares between the windows of this session's worktree, starting it on first use."""
+        key = WorktreeKey.from_context(session.repository_context)
+        shared = shared_by_key.get(key)
+        if shared is None:
+            shared = self.begin_full_refresh_read(key, explicit=explicit)
+            shared_by_key[key] = shared
+        return shared
+
+    def _join_full_refresh_read(self, session: RepositorySession, offered: FullRefreshRead | None) -> FullRefreshRead:
+        """Register a complete refresh in the shared read it was offered, or in a new one, and make sure that read is asked for.
+
+        An offered entry is joined only while it is still the latest one of this worktree and was started with the same
+        Git; otherwise the refresh reads for itself.
+        """
+        key = WorktreeKey.from_context(session.repository_context)
+        shared = offered
+        if shared is None or self.full_refresh_read_by_key.get(key) is not shared or shared.key != key or shared.git_filename != self.repository.git_filename:
+            shared = self.begin_full_refresh_read(key)
+        if not shared.worktree_read_requested:
+            shared.worktree_read_requested = True
+            staging = self.staging_session_registry_controller.staging_session(session.repository_context)
+            # Whether it starts now or waits for a read already running, the read asked here gets the next number. It is
+            # recorded first because an explicit read already publishes the stale state while it is being asked for.
+            shared.staging_generation = staging.generation + 1
+            staging.refresh(explicit=shared.explicit)
+        return shared
+
+    def _observe_full_refresh_pause(self, shared: FullRefreshRead) -> None:
+        """Look at the rebase and replay state once for every window registered in a shared refresh.
+
+        The observation is asked through the first window still open at the generation it registered with; it publishes
+        to every current window of that worktree. A replay state the ending operation published is shown instead of
+        read, once, and only while it is still current.
+        """
+        if shared.pause_observed:
+            return
+        for session_id, generation in tuple(shared.session_generation_by_id.items()):
+            session = self.session_registry_controller.session_by_id.get(session_id)
+            if session is None or session.is_closed or session.generation != generation or not self.operation_policy_controller.allows(session_id, WindowCapability.MANAGE):
+                continue
+            shared.pause_observed = True
+            same_git = shared.git_filename == self.repository.git_filename
+            publication = shared.replay_publication if same_git else None
+            rebase_publication = shared.rebase_publication if same_git else None
+            shared.replay_publication = None
+            shared.rebase_publication = None
+            self.pause_observation_requested.emit(session_id, publication, rebase_publication)
+            return
+
+    def observe_full_refresh_pauses(self, shared_by_key: dict[WorktreeKey, FullRefreshRead]) -> set[WorktreeKey]:
+        """Observe the pause state once per worktree an operation result refreshed; answer the worktrees whose windows were refreshed."""
+        refreshed_key_set: set[WorktreeKey] = set()
+        for key, shared in shared_by_key.items():
+            if not shared.session_generation_by_id:
+                continue
+            refreshed_key_set.add(key)
+            self._observe_full_refresh_pause(shared)
+        return refreshed_key_set
+
+    def full_refresh_covers(self, key: WorktreeKey, staging: StagingSession) -> bool:
+        """Tell whether the working tree state just published belongs to a shared refresh that observes the pause state itself.
+
+        The publication of the shared read itself is the last one covered.
+        """
+        shared = self.full_refresh_read_by_key.get(key)
+        if shared is None or not shared.worktree_read_requested or shared.read_published or staging.generation > shared.staging_generation:
+            return False
+        if staging.generation == shared.staging_generation and not staging.refresh_active:
+            shared.read_published = True
+        return True
+
+    def full_refresh_reads(self, key: WorktreeKey, staging: StagingSession) -> bool:
+        """Tell, without marking anything, whether the working tree state just published was read for a shared refresh of this worktree."""
+        shared = self.full_refresh_read_by_key.get(key)
+        return shared is not None and shared.worktree_read_requested and staging.generation <= shared.staging_generation
+
+    def leave_full_refresh_read(self, session_id: str) -> None:
+        """Forget a window's place in the shared refresh of its worktree once its own refresh has ended or it closed.
+
+        Once no window waits any more and the shared working tree read is over, the entry is dropped and covers no later
+        publication.
+        """
+        for key, shared in tuple(self.full_refresh_read_by_key.items()):
+            if shared.session_generation_by_id.pop(session_id, None) is None or shared.session_generation_by_id:
+                continue
+            staging = self.staging_session_registry_controller.staging_by_key.get(key)
+            if staging is None or (staging.generation >= shared.staging_generation and not staging.refresh_active):
+                del self.full_refresh_read_by_key[key]
+
+    def read_submodules(self, session_id: str) -> None:
+        """Refresh the declared family only for its still-current management view."""
+        if not self.operation_policy_controller.allows(session_id, WindowCapability.MANAGE):
+            return
+        session = self.session_registry_controller.session_by_id[session_id]
+        if session.repository_context.is_bare:
+            return
+        identity = self.session_registry_controller.identity_by_session[session_id]
+        generation = self.submodule_read_generation_by_session.get(session_id, 0) + 1
+        self.submodule_read_generation_by_session[session_id] = generation
+        previous = self.submodule_snapshot_by_session.get(session_id)
+
+        def receive(snapshot: SubmoduleSnapshot | None, error: Exception | None) -> None:
+            """Drop old family reads instead of painting them over a new context."""
+            if (self.session_registry_controller.identity_by_session.get(session_id) != identity or session_id not in self.session_registry_controller.window_by_session
+                    or self.submodule_read_generation_by_session.get(session_id) != generation):
+                return
+            if error is not None:
+                cause = Diagnostic("Read submodules", session.repository_context.repository_dir, "", [], str(error)).prepare().cause
+                self.session_registry_controller.window_by_session[session_id].statusBar().showMessage(cause)
+                self.session_registry_controller.window_by_session[session_id].show_parent_reference(None, "Unavailable", cause)
+                if previous is not None:
+                    unknown_entries = tuple(replace(entry, submodule=SubmoduleState()) for entry in previous.entries)
+                    unknown = replace(previous, entries=unknown_entries, cause=cause)
+                    self.submodule_snapshot_by_session[session_id] = unknown
+                    self.session_registry_controller.window_by_session[session_id].show_submodules(unknown)
+                return
+            self.publish_submodule_family(session_id, snapshot, identity, generation)
+
+        self.submodule.read(session.repository_context, self.repository.git_filename, receive, previous.root_dir if previous else None)
+
+    def publish_submodule_family(self, session_id: str, snapshot: SubmoduleSnapshot, identity: RequestIdentity, generation: int) -> None:
+        """Show one valid family in its still-current window, then read the committed parent reference of its repository.
+
+        Both a family read and a walk into another repository end here, so the window, its identity and the family read
+        generation are checked the same way before anything is shown, and again when the parent reference arrives.
+        """
+        if (self.session_registry_controller.identity_by_session.get(session_id) != identity or session_id not in self.session_registry_controller.window_by_session
+                or self.submodule_read_generation_by_session.get(session_id) != generation):
+            return
+        session = self.session_registry_controller.session_by_id[session_id]
+        self.submodule_snapshot_by_session[session_id] = snapshot
+        self.session_registry_controller.window_by_session[session_id].show_submodules(snapshot)
+        entry = next((entry for entry in snapshot.entries if canonical_path(entry.repository_dir) == canonical_path(session.repository_context.repository_dir)), None)
+        if entry is None or entry.parent_dir is None:
+            self.session_registry_controller.window_by_session[session_id].show_parent_reference(None)
+            return
+
+        def reference_read(reference: SubmoduleReferenceState | None, error: Exception | None) -> None:
+            """Publish a committed gitlink only while its child view still owns this read."""
+            if (self.session_registry_controller.identity_by_session.get(session_id) != identity or session_id not in self.session_registry_controller.window_by_session
+                    or self.submodule_read_generation_by_session.get(session_id) != generation):
+                return
+            window = self.session_registry_controller.window_by_session[session_id]
+            previous_oid = window.history_model.committed_parent_oid
+            if error is not None or reference is None:
+                cause = Diagnostic("Read committed parent reference", entry.parent_dir, "", [], str(error or "No parent reference result")).prepare().cause
+                window.show_parent_reference(None, "Unavailable", cause)
+                return
+            cause = Diagnostic("Read committed parent reference", entry.parent_dir, "", [], reference.cause).prepare().cause if reference.cause else ""
+            window.show_parent_reference(reference.committed_oid, reference.committed_availability, cause)
+            oid = window.history_model.committed_parent_oid
+            if oid is not None and oid != previous_oid and (session.snapshot is None or oid not in session.snapshot.ordered_oids):
+                self.refresh(session_id)
+
+        self.submodule.read_reference_state(session.repository_context, self.repository.git_filename, os.fsencode(entry.path), reference_read, parent_dir=entry.parent_dir)
+
+    def refresh(self, session_id: str, recovery: bool = False, *, scope: RefreshScope = RefreshScope.FULL,
+                 reference_snapshot: ReferenceSnapshot | None = None, source_session_id: str | None = None,
+                 full_refresh_read: FullRefreshRead | None = None, outside_already_read: bool = False, selection_oid: str | None = None) -> None:
+        """Keep one active refresh and at most one waiting request while retaining the old view.
+
+        ``scope`` REFERENCES reads references and graph only; ``reference_snapshot`` is the final capture of the
+        operation of ``source_session_id``, which the caller already checked belongs to this window's worktree.
+        ``full_refresh_read`` registers the window in the working tree read an operation result shares between the
+        windows it refreshes; the caller then observes the pause state once for all of them. ``outside_already_read``
+        keeps a REFERENCES refresh from reading the working tree and the pause state again when HEAD moved, because the
+        caller has just read them.
+        """
+        if not self.operation_policy_controller.allows(session_id, WindowCapability.MANAGE) or session_id not in self.session_registry_controller.window_by_session:
+            return
+        session = self.session_registry_controller.session_by_id[session_id]
+        request = RefreshRequest(scope, reference_snapshot, source_session_id if reference_snapshot is not None else None,
+                                 reference_snapshot.generation if reference_snapshot is not None else None, session.generation, recovery,
+                                 full_refresh_read, outside_already_read, selection_oid)
+        self.submit_refresh_request(session_id, request)
+
+    def submit_refresh_request(self, session_id: str, request: RefreshRequest) -> None:
+        """Start one refresh request now, or merge it into the request waiting behind the running refresh."""
+        if not self.operation_policy_controller.allows(session_id, WindowCapability.MANAGE):
+            return
+        window = self.session_registry_controller.window_by_session.get(session_id)
+        if window is None:
+            return
+        session = self.session_registry_controller.session_by_id[session_id]
+        if session.refresh_active:
+            session.refresh_queued = request if session.refresh_queued is None else session.refresh_queued.merged_with(request)
+            return
+        observation = self._usable_reference_observation(session, request)
+        previous_displayed = self.reference_read_controller.reference_snapshot_by_session.get(session_id)
+        shared = None
+        if request.scope is RefreshScope.FULL and not session.repository_context.is_bare:
+            shared = self._join_full_refresh_read(session, request.full_refresh_read)
+        session.view_anchor = window.capture_anchor()
+        if request.selection_oid is not None:
+            session.selected_oid = request.selection_oid
+            session.navigation_oid = None
+            session.navigation_commit = None
+            session.selection_generation += 1
+            session.view_anchor = replace(session.view_anchor, selected_oid=request.selection_oid)
+        session.refresh_active = True
+        session.search(window.filter_edit.text())
+        session.snapshot = None
+        window.search_timer.stop()
+        window.search_pending = False
+        window.commit_list.setEnabled(True)
+        window.history_state_label.hide()
+        previous = self.session_registry_controller.identity_by_session[session_id]
+        identity = RequestIdentity(session_id, previous.generation + 1)
+        self.session_registry_controller.identity_by_session[session_id] = identity
+        session.generation = identity.generation
+        session.invalidate_file_selection()
+        self.session_registry_controller.generation_by_session[session_id] = identity.generation
+        self.refresh_started.emit(session_id)
+        if shared is not None:
+            shared.session_generation_by_id[session_id] = identity.generation
+            if shared is not request.full_refresh_read:
+                # Nobody registered this window in a shared read: this refresh observes the pause state itself.
+                self._observe_full_refresh_pause(shared)
+        elif request.scope is RefreshScope.FULL:
+            self.pause_observation_requested.emit(session_id, None, None)
+        window.diff_panel.clear_selection("Loading diff…")
+        window.file_tree_panel.clear_selection("Loading tree…")
+        if request.recovery:
+            self.recovery_request_set.add(identity)
+        window.statusBar().showMessage(SharedText.HISTORY_REFRESH.value)
+        # The capture handed over by the operation is shown under the generation this refresh owns; its files are still
+        # checked unchanged before it is.
+        shown_again = replace(observation, generation=identity.generation) if observation is not None else None
+        before_history = None
+        if request.scope is RefreshScope.REFERENCES and not request.outside_already_read:
+            def before_history(snapshot: ReferenceSnapshot | None, error: Exception | None) -> None:
+                """Read everything else too when HEAD moved, or when the references could not be read at all."""
+                if error is None and snapshot is not None and previous_displayed is not None and snapshot.head_oid == previous_displayed.head_oid:
+                    return
+                self._read_outside_references(session_id)
+        self.reference_read_controller.read_history_with_references(session_id, identity, window.history_model.committed_parent_oid, previous=shown_again, before_history=before_history)
+        if request.scope is RefreshScope.FULL:
+            self.read_submodules(session_id)
+
+    def _usable_reference_observation(self, session: RepositorySession, request: RefreshRequest) -> ReferenceSnapshot | None:
+        """Answer the handed-over capture only while it still describes this window's repository, Git and generation.
+
+        Another generation of the window since the request, a closed source window, another Git or another worktree
+        drops it, and the refresh reads the references again.
+        """
+        observation = request.reference_snapshot
+        if observation is None or session.generation != request.target_generation:
+            return None
+        if request.source_session_id is not None:
+            source = self.session_registry_controller.session_by_id.get(request.source_session_id)
+            if source is None or source.is_closed:
+                return None
+        if observation.context != session.repository_context or observation.git_filename != self.repository.git_filename:
+            return None
+        return observation
+
+    def _read_outside_references(self, session_id: str) -> None:
+        """Read the working tree, the rebase state and the submodules of a window whose reference-only refresh found HEAD moved."""
+        session = self.session_registry_controller.session_by_id.get(session_id)
+        if session is None or session.is_closed or not self.operation_policy_controller.allows(session_id, WindowCapability.MANAGE):
+            return
+        if not session.repository_context.is_bare:
+            self.staging_session_registry_controller.staging_session(session.repository_context).refresh()
+        self.pause_observation_requested.emit(session_id, None, None)
+        self.read_submodules(session_id)
+
+    def refresh_after_reference_operation(self, operation: OperationIntent, outcome: OperationOutcome, scope: RefreshScope,
+                                          *, replacement_by_oid: dict[str, str | None] | None = None) -> None:
+        """Refresh every window of the operation's repository, handing its final capture to the windows of its own worktree.
+
+        The origin is checked once, before the first refresh starts a new generation: the source window must still be
+        at the generation the operation was captured in, with the same Git and repository. A linked worktree has its
+        own HEAD, so its windows always read their references themselves.
+        """
+        observation = final_reference_snapshot(outcome)
+        source = self.session_registry_controller.session_by_id.get(operation.session_id) if operation.session_id is not None else None
+        if (observation is None or source is None or source.is_closed or source.generation != operation.generation
+                or source.repository_context != operation.context or observation.context != operation.context
+                or observation.git_filename != operation.git_filename or self.repository.git_filename != operation.git_filename):
+            observation = None
+        observation_by_session: dict[str, ReferenceSnapshot | None] = {}
+        for session_id, session in tuple(self.session_registry_controller.session_by_id.items()):
+            if not session.is_closed and canonical_path(session.repository_context.common_git_dir) == operation.common_git_dir:
+                shared = observation is not None and session.repository_context == observation.context
+                observation_by_session[session_id] = observation if shared else None
+        shared_by_key: dict[WorktreeKey, FullRefreshRead] = {}
+        for session_id, shared_observation in observation_by_session.items():
+            self.checkout_refresh_session_set.add(session_id)
+            session = self.session_registry_controller.session_by_id[session_id]
+            full_refresh_read = self.full_refresh_read_for(session, shared_by_key) if scope is RefreshScope.FULL else None
+            selection_oid = None
+            if replacement_by_oid is not None and session.selected_oid in replacement_by_oid:
+                selection_oid = replacement_by_oid[session.selected_oid]
+                if selection_oid is None:
+                    snapshot = self.reference_read_controller.reference_snapshot_by_session.get(session_id)
+                    if snapshot is not None:
+                        selection_oid = replacement_by_oid.get(snapshot.head_oid, snapshot.head_oid)
+            self.refresh(session_id, scope=scope, reference_snapshot=shared_observation, source_session_id=operation.session_id,
+                         full_refresh_read=full_refresh_read, selection_oid=selection_oid)
+        self.observe_full_refresh_pauses(shared_by_key)