Struct Host 

pub struct Host<T> { /* private fields */ }

The remote-host side of a run, over whichever store holds its state.

It is both interfaces at once: a RemoteHost a journey can call directly, and the Hosting factory a run is handed. A host taken from the factory shares this one’s state, so what a publication did is read back through the value the journey created.

Implementations

impl Host<MemoryStore<HostState>>

pub fn new() -> Self

A host with nothing opened against it.

pub fn seeded(state: HostState) -> Self

A host that starts from a scenario.

pub fn state(&self) -> HostState

Everything it knows.

impl Host<FileStore<HostState>>

pub fn create(path: impl Into<PathBuf>) -> Result<Self>

A host keeping its state at path: whatever is already there, or nothing opened against it.

Attaching rather than replacing, so a second host over the same path answers about the change requests the first one opened.

pub fn seeded(path: impl Into<PathBuf>, state: HostState) -> Result<Self>

A host that starts from a scenario, keeping its state at path and replacing whatever was there.

pub fn state(&self) -> Result<HostState>

Everything it knows, read back out of its document.

Trait Implementations

impl<T: Debug> Debug for Host<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T: Store<HostState> + Clone + Debug + Send + Sync + 'static> Hosting for Host<T>

fn for_repo(&self, slug: &str) -> Result<Box<dyn RemoteHost>>

The host that answers for the repository named owner/name.

impl<T: Store<HostState>> RemoteHost for Host<T>

fn ready_for_review(&self, cr: &ChangeRequest) -> Result<()>

Take the change request out of its draft state.

The call itself is what is recorded, rather than a flag that would read the same whether it was made once or twice: what a journey asks of this is whether a second publication over an already-lifted change asked the host for anything, and only the calls can answer that. A change already open for review is already what this asks for, so it succeeds — the caller wanted it ready, and it is.

fn required_checks_on(&self, _base: &str) -> Result<RequiredChecks>

What the repository requires before a merge into base: the seeded answer, or — unset — exactly the checks seeded as required, completely.

fn describe_change( &self, cr: &ChangeRequest, title: Option<&str>, body: &str, ) -> Result<()>

Replace the description, recording the call.

The title and body go where open_change put the ones it was given, so what change_description reads back is the same record whichever call wrote it — and the call itself is kept, for the reason ready_for_review’s is: a journey about a closeout asks what was written and in what order, and the current description cannot say. A title that names nothing is refused as the real host refuses one; a body is prose, and an empty one is a description a caller may mean.

fn change_description(&self, cr: &ChangeRequest) -> Result<Description>

The description as this host holds it: the title it was opened or last described with, and the body — empty where it was opened with none and never described since, which is what the real host answers for one.

fn authenticated_user(&self) -> Result<String>

Who the host believes is calling.

fn open_change(&self, req: ChangeSpec) -> Result<ChangeRequest>

Open a change request.

fn find_changes(&self, head: &str, base: &str) -> Result<Vec<ChangeRequest>>

Every open change request from head into base.

fn change_checks(&self, cr: &ChangeRequest) -> Result<ChangeChecks>

The checks the host is reporting on a change request, and which of its sources that answer was read from.

fn check_log(&self, cr: &ChangeRequest, check: &Check) -> Result<ArtifactId>

Store one check’s log as an artifact and return its id.

fn merge(&self, cr: &ChangeRequest, policy: MergePolicy) -> Result<MergeOutcome>

Merge a change request under a policy.

fn is_draft(&self, cr: &ChangeRequest) -> Result<bool>

Whether the host is holding this change request as a draft.

fn merged_at(&self, cr: &ChangeRequest) -> Result<Option<Sha>>

The commit a change request reached its base at, or None while the host has not merged it.

fn mergeability(&self, _cr: &ChangeRequest) -> Result<Mergeability, Error>

Whether a change request can still merge into its base, as the host has computed it.