Skip to main content

RegistryService

Struct RegistryService 

Source
pub struct RegistryService { /* private fields */ }
Expand description

ZMQ-based registry service

Wraps git2db::Git2DB and provides a Cap’n Proto interface over ZMQ.

§Streaming Support

Streaming clone uses the Continuation pipeline (same as inference streaming):

  1. Handler performs DH key exchange and returns (StreamInfo, Continuation)
  2. Dispatch serializes StreamInfo as the REP response
  3. RequestLoop spawns the Continuation after REP is sent
  4. Continuation publishes clone progress via PUB/SUB

The registry is wrapped in RwLock for interior mutability since some operations (like clone) require mutable access but RequestService::handle_request takes &self.

Implementations§

Source§

impl RegistryService

Source

pub async fn new( base_dir: impl AsRef<Path>, policy_client: PolicyClient, transport: TransportConfig, signing_key: SigningKey, ) -> Result<Self>

Create a new registry service with infrastructure

Must be called from within a tokio runtime context.

Source

pub fn with_expected_audience(self, audience: String) -> Self

Set the expected JWT audience for token validation.

Source

pub fn with_ninep_canonical_read( self, export: NinepCanonicalReadConfig, issuer: String, ) -> Result<Self>

Admit only an operator-selected repository/worktree through a separate live relay grant. This does not grant the OAI service a Registry scope.

Source

pub fn with_pds_publisher(self, publisher: PdsPublisher) -> Self

Wire in the PDS publisher (#910a). Registration and commitWithAuthor (the RPC promote also drives) will publish/advance the repo’s ai.hyprstream.model record through it.

Source

pub fn with_pds_publisher_arc(self, publisher: Arc<PdsPublisher>) -> Self

Like Self::with_pds_publisher but takes an already-Arc’d publisher, so the caller can retain a weak clone for the ES256 promotion hook (#918).

Source

pub fn with_jwt_key_source(self, src: Arc<dyn JwtKeySource>) -> Self

Set the JWT key source for token verification.

Source

pub fn with_cas_pep(self, pep: Arc<CasPep>) -> Self

Install the production CAS PEP used by streaming continuations.

Trait Implementations§

Source§

impl CtlHandler for RegistryService

Source§

fn handle_status<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, ctx: &'life1 EnvelopeContext, _request_id: u64, repo_id: &'life2 str, _name: &'life3 str, fid: u32, ) -> Pin<Box<dyn Future<Output = Result<FileStatus>> + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Git status of this file.

Source§

fn handle_log<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, ctx: &'life1 EnvelopeContext, _request_id: u64, repo_id: &'life2 str, _name: &'life3 str, fid: u32, data: &'life4 CtlLogRequest, ) -> Pin<Box<dyn Future<Output = Result<Vec<LogEntry>>> + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait,

Commits touching this file.

Source§

fn handle_diff<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, ctx: &'life1 EnvelopeContext, _request_id: u64, repo_id: &'life2 str, _name: &'life3 str, fid: u32, data: &'life4 CtlDiffRequest, ) -> Pin<Box<dyn Future<Output = Result<String>> + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait,

Diff this file against a ref.

Source§

fn handle_blame<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, ctx: &'life1 EnvelopeContext, _request_id: u64, repo_id: &'life2 str, _name: &'life3 str, fid: u32, ) -> Pin<Box<dyn Future<Output = Result<String>> + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Git blame for this file.

Source§

fn handle_checkout<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, ctx: &'life1 EnvelopeContext, _request_id: u64, repo_id: &'life2 str, name: &'life3 str, fid: u32, data: &'life4 CtlCheckoutRequest, ) -> Pin<Box<dyn Future<Output = Result<()>> + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait,

Restore file content from a ref.

Source§

fn handle_validate<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, ctx: &'life1 EnvelopeContext, _request_id: u64, repo_id: &'life2 str, name: &'life3 str, fid: u32, ) -> Pin<Box<dyn Future<Output = Result<ValidationResult>> + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Validate file format.

Source§

fn handle_info<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, ctx: &'life1 EnvelopeContext, _request_id: u64, _repo_id: &'life2 str, _name: &'life3 str, fid: u32, ) -> Pin<Box<dyn Future<Output = Result<FileInfo>> + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

File metadata and git state.

Source§

fn handle_edit_open<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, ctx: &'life1 EnvelopeContext, _request_id: u64, repo_id: &'life2 str, name: &'life3 str, fid: u32, data: &'life4 EditOpenRequest, ) -> Pin<Box<dyn Future<Output = Result<()>> + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait,

Open file for CRDT editing.

Source§

fn handle_edit_state<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, ctx: &'life1 EnvelopeContext, _request_id: u64, _repo_id: &'life2 str, _name: &'life3 str, fid: u32, ) -> Pin<Box<dyn Future<Output = Result<String>> + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Get current CRDT document state.

Source§

fn handle_edit_apply<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, ctx: &'life1 EnvelopeContext, _request_id: u64, _repo_id: &'life2 str, _name: &'life3 str, fid: u32, data: &'life4 EditApplyRequest, ) -> Pin<Box<dyn Future<Output = Result<()>> + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait,

Apply automerge CRDT change.

Source§

fn handle_edit_close<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, ctx: &'life1 EnvelopeContext, _request_id: u64, _repo_id: &'life2 str, _name: &'life3 str, fid: u32, ) -> Pin<Box<dyn Future<Output = Result<()>> + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Close CRDT editing session.

Source§

fn handle_ctl_flush<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, ctx: &'life1 EnvelopeContext, _request_id: u64, repo_id: &'life2 str, name: &'life3 str, fid: u32, ) -> Pin<Box<dyn Future<Output = Result<()>> + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Write CRDT state to disk file.

Source§

impl RegistryHandler for RegistryService

Source§

fn handle_put_blob<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, ctx: &'life1 EnvelopeContext, _request_id: u64, data: &'life2 PutBlobRequest, ) -> Pin<Box<dyn Future<Output = Result<RegistryResponseVariant>> + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Authenticated in-band XET write (epic #654) — the symmetric write half of getBlob and what populates the provenance store the #509 read-gate consults. The caller supplies bytes only; the server computes the merkle from those bytes (never caller-supplied — this is what closes the #436 OID-planting vector by construction) and binds (merkle → grantRepo) provenance from the verified identity.

The coarse $scope(write) gate runs in dispatch before this handler (as $scope(query) does for handle_get_blob; neither carries #[authorize]). A failure returns a fail-closed error response — no bytes are persisted and no provenance is recorded unless the caller is authorized.

Source§

fn authorize<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, ctx: &'life1 EnvelopeContext, resource: &'life2 str, operation: &'life3 str, ) -> Pin<Box<dyn Future<Output = Result<()>> + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Authorize an operation on a resource. Override to enforce policy. Read more
Source§

fn handle_list<'life0, 'life1, 'async_trait>( &'life0 self, ctx: &'life1 EnvelopeContext, _request_id: u64, ) -> Pin<Box<dyn Future<Output = Result<RegistryResponseVariant>> + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Handle list request.
Source§

fn handle_get<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, _ctx: &'life1 EnvelopeContext, _request_id: u64, value: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<RegistryResponseVariant>> + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Handle get request.
Source§

fn handle_get_by_name<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, _ctx: &'life1 EnvelopeContext, _request_id: u64, value: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<RegistryResponseVariant>> + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Handle getByName request.
Source§

fn handle_clone<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, _ctx: &'life1 EnvelopeContext, _request_id: u64, data: &'life2 CloneRequest, ) -> Pin<Box<dyn Future<Output = Result<RegistryResponseVariant>> + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Handle clone request.
Source§

fn handle_clone_stream<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, ctx: &'life1 EnvelopeContext, _request_id: u64, data: &'life2 CloneRequest, ) -> Pin<Box<dyn Future<Output = Result<(StreamInfo, Continuation)>> + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Handle cloneStream streaming request. Returns (StreamInfo, mandatory continuation).
Source§

fn handle_get_blob<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, ctx: &'life1 EnvelopeContext, _request_id: u64, data: &'life2 GetBlobRequest, ) -> Pin<Box<dyn Future<Output = Result<(StreamInfo, Continuation)>> + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Handle getBlob streaming request. Returns (StreamInfo, mandatory continuation).
Source§

fn handle_register<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, _ctx: &'life1 EnvelopeContext, _request_id: u64, data: &'life2 RegisterRequest, ) -> Pin<Box<dyn Future<Output = Result<RegistryResponseVariant>> + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Handle register request.
Source§

fn handle_remove<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, _ctx: &'life1 EnvelopeContext, _request_id: u64, value: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<RegistryResponseVariant>> + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Handle remove request.
Source§

fn handle_health_check<'life0, 'life1, 'async_trait>( &'life0 self, _ctx: &'life1 EnvelopeContext, _request_id: u64, ) -> Pin<Box<dyn Future<Output = Result<RegistryResponseVariant>> + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Handle healthCheck request.
Source§

fn handle_ingest_at9p_candidate<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, _ctx: &'life1 EnvelopeContext, _request_id: u64, data: &'life2 At9pCandidateRequest, ) -> Pin<Box<dyn Future<Output = Result<RegistryResponseVariant>> + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Handle ingestAt9pCandidate request.
Source§

fn is_resource_authorized<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, ctx: &'life1 EnvelopeContext, resource: &'life2 str, operation: &'life3 str, ) -> Pin<Box<dyn Future<Output = bool> + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Check if a specific resource+operation is authorized (non-failing). Read more
Source§

impl RepoHandler for RegistryService

Source§

fn handle_create_worktree<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, _ctx: &'life1 EnvelopeContext, _request_id: u64, repo_id: &'life2 str, data: &'life3 CreateWorktreeRequest, ) -> Pin<Box<dyn Future<Output = Result<()>> + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Ensure a worktree exists for a branch, creating if needed
Source§

fn handle_list_worktrees<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, _ctx: &'life1 EnvelopeContext, _request_id: u64, repo_id: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<Vec<WorktreeInfo>>> + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Handle listWorktrees request.
Source§

fn handle_remove_worktree<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, _ctx: &'life1 EnvelopeContext, _request_id: u64, repo_id: &'life2 str, data: &'life3 RemoveWorktreeRequest, ) -> Pin<Box<dyn Future<Output = Result<()>> + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Handle removeWorktree request.
Source§

fn handle_create_branch<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, _ctx: &'life1 EnvelopeContext, _request_id: u64, repo_id: &'life2 str, data: &'life3 BranchRequest, ) -> Pin<Box<dyn Future<Output = Result<()>> + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Handle createBranch request.
Source§

fn handle_list_branches<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, _ctx: &'life1 EnvelopeContext, _request_id: u64, repo_id: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<Vec<String>>> + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Handle listBranches request.
Source§

fn handle_checkout<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, _ctx: &'life1 EnvelopeContext, _request_id: u64, _repo_id: &'life2 str, _data: &'life3 CheckoutRequest, ) -> Pin<Box<dyn Future<Output = Result<()>> + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Handle checkout request.
Source§

fn handle_stage_all<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, _ctx: &'life1 EnvelopeContext, _request_id: u64, _repo_id: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<()>> + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Handle stageAll request.
Source§

fn handle_stage_files<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, _ctx: &'life1 EnvelopeContext, _request_id: u64, _repo_id: &'life2 str, _data: &'life3 StageFilesRequest, ) -> Pin<Box<dyn Future<Output = Result<()>> + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Handle stageFiles request.
Source§

fn handle_commit<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, _ctx: &'life1 EnvelopeContext, _request_id: u64, _repo_id: &'life2 str, _data: &'life3 CommitRequest, ) -> Pin<Box<dyn Future<Output = Result<String>> + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Handle commit request.
Source§

fn handle_merge<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, _ctx: &'life1 EnvelopeContext, _request_id: u64, _repo_id: &'life2 str, _data: &'life3 MergeRequest, ) -> Pin<Box<dyn Future<Output = Result<()>> + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Handle merge request.
Source§

fn handle_abort_merge<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, _ctx: &'life1 EnvelopeContext, _request_id: u64, _repo_id: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<()>> + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Handle abortMerge request.
Source§

fn handle_continue_merge<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, _ctx: &'life1 EnvelopeContext, _request_id: u64, _repo_id: &'life2 str, _data: &'life3 ContinueMergeRequest, ) -> Pin<Box<dyn Future<Output = Result<()>> + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Handle continueMerge request.
Source§

fn handle_quit_merge<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, _ctx: &'life1 EnvelopeContext, _request_id: u64, _repo_id: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<()>> + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Handle quitMerge request.
Source§

fn handle_get_head<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, _ctx: &'life1 EnvelopeContext, _request_id: u64, repo_id: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<String>> + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Handle getHead request.
Source§

fn handle_get_ref<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, _ctx: &'life1 EnvelopeContext, _request_id: u64, repo_id: &'life2 str, data: &'life3 GetRefRequest, ) -> Pin<Box<dyn Future<Output = Result<String>> + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Handle getRef request.
Source§

fn handle_status<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, _ctx: &'life1 EnvelopeContext, _request_id: u64, repo_id: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<RepositoryStatus>> + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Handle status request.
Source§

fn handle_detailed_status<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, _ctx: &'life1 EnvelopeContext, _request_id: u64, repo_id: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<DetailedStatusInfo>> + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Handle detailedStatus request.
Source§

fn handle_list_remotes<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, _ctx: &'life1 EnvelopeContext, _request_id: u64, repo_id: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<Vec<RemoteInfo>>> + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Handle listRemotes request.
Source§

fn handle_add_remote<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, _ctx: &'life1 EnvelopeContext, _request_id: u64, repo_id: &'life2 str, data: &'life3 AddRemoteRequest, ) -> Pin<Box<dyn Future<Output = Result<()>> + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Handle addRemote request.
Source§

fn handle_remove_remote<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, _ctx: &'life1 EnvelopeContext, _request_id: u64, repo_id: &'life2 str, data: &'life3 RemoveRemoteRequest, ) -> Pin<Box<dyn Future<Output = Result<()>> + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Handle removeRemote request.
Source§

fn handle_set_remote_url<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, _ctx: &'life1 EnvelopeContext, _request_id: u64, repo_id: &'life2 str, data: &'life3 SetRemoteUrlRequest, ) -> Pin<Box<dyn Future<Output = Result<()>> + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Handle setRemoteUrl request.
Source§

fn handle_rename_remote<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, _ctx: &'life1 EnvelopeContext, _request_id: u64, repo_id: &'life2 str, data: &'life3 RenameRemoteRequest, ) -> Pin<Box<dyn Future<Output = Result<()>> + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Handle renameRemote request.
Source§

fn handle_push<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, _ctx: &'life1 EnvelopeContext, _request_id: u64, repo_id: &'life2 str, data: &'life3 PushRequest, ) -> Pin<Box<dyn Future<Output = Result<()>> + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Handle push request.
Source§

fn handle_amend_commit<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, _ctx: &'life1 EnvelopeContext, _request_id: u64, _repo_id: &'life2 str, _data: &'life3 AmendCommitRequest, ) -> Pin<Box<dyn Future<Output = Result<String>> + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Handle amendCommit request.
Source§

fn handle_commit_with_author<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, _ctx: &'life1 EnvelopeContext, _request_id: u64, _repo_id: &'life2 str, _data: &'life3 CommitWithAuthorRequest, ) -> Pin<Box<dyn Future<Output = Result<String>> + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Handle commitWithAuthor request.
Source§

fn handle_stage_all_including_untracked<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, _ctx: &'life1 EnvelopeContext, _request_id: u64, _repo_id: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<()>> + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Handle stageAllIncludingUntracked request.
Source§

fn handle_list_tags<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, _ctx: &'life1 EnvelopeContext, _request_id: u64, repo_id: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<Vec<String>>> + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Handle listTags request.
Source§

fn handle_create_tag<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, _ctx: &'life1 EnvelopeContext, _request_id: u64, repo_id: &'life2 str, data: &'life3 CreateTagRequest, ) -> Pin<Box<dyn Future<Output = Result<()>> + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Handle createTag request.
Source§

fn handle_delete_tag<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, _ctx: &'life1 EnvelopeContext, _request_id: u64, repo_id: &'life2 str, data: &'life3 DeleteTagRequest, ) -> Pin<Box<dyn Future<Output = Result<()>> + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Handle deleteTag request.
Source§

fn handle_update<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, _ctx: &'life1 EnvelopeContext, _request_id: u64, repo_id: &'life2 str, data: &'life3 UpdateRequest, ) -> Pin<Box<dyn Future<Output = Result<()>> + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Handle update request.
Source§

impl RequestService for RegistryService

Source§

fn accept_deferred_federate_credential(&self) -> bool

Opt in only when this serving instance has a complete request-local holder-proof, current-primary and durable Policy-use adapter. Default false preserves the generic verifier’s reserved-profile denial.
Source§

fn admit_deferred_federate_request<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, ctx: &'life1 EnvelopeContext, body: &'life2 DecodedRequestBody, proof: &'life3 ParsedProof, ) -> Pin<Box<dyn Future<Output = Result<(VerifiedProof, [u8; 32], String, String, ProofReplayKey, u64)>> + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Verify the original holder’s proof and bind it to the exact decoded body/leaf/resource/action before identity publication. This stage must not consume replay state: generated method-policy and MAC authorization still run afterward. Durable Policy admission happens in commit_deferred_federate_request only after those gates pass.
Source§

fn commit_deferred_federate_request<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, ctx: &'life1 EnvelopeContext, resource: &'life2 str, operation: &'life3 str, replay_key: &'life4 ProofReplayKey, replay_expiry: u64, ) -> Pin<Box<dyn Future<Output = Result<()>> + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait,

Perform fresh Policy admission and durable replay consumption after the generated method-policy and mandatory MAC gates, immediately before handler dispatch. Implementations must fail closed if the durable admission service is unavailable. The default never admits a request.
Source§

fn decode_request_body(&self, signed_body: &[u8]) -> Result<DecodedRequestBody>

Decode the signed request body exactly once (bounded) and derive the full numeric method leaf path (v16 §5.2 step 4). Read more
Source§

fn producer_reach_config_handle(&self) -> Option<ProducerReachConfigHandle>

Mutable reach source filled by the unified service spawner after the service’s QUIC and iroh listeners bind.
Source§

fn moq_origin_handle(&self) -> Option<MoqStreamOriginHandle>

Optional per-service MoQ origin source. The unified spawner installs a scoped origin here when this service has a relay configured.
Source§

fn handle_request<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, ctx: &'life1 EnvelopeContext, body: &'life2 DecodedRequestBody, ) -> Pin<Box<dyn Future<Output = Result<(Vec<u8>, Option<Continuation>)>> + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Process a request and return a response with optional continuation. Read more
Source§

fn name(&self) -> &str

Service name (for logging and registry).
Source§

fn transport(&self) -> &TransportConfig

Transport configuration (endpoint binding).
Source§

fn signing_key(&self) -> SigningKey

Ed25519 signing key for signing responses.
Source§

fn expected_audience(&self) -> Option<&str>

Expected audience (resource URL) for JWT validation. Read more
Source§

fn accept_delegated_bearer(&self, signer: &[u8; 32]) -> bool

Accept a relayed bearer from this verified envelope signer. Services enabling this must pin an independently configured controller key.
Source§

fn delegated_user_audience( &self, signer: &[u8; 32], untrusted_aud: Option<&str>, ) -> Option<&str>

Select an exact, configured audience for an already-admitted delegated user bearer. The unverified claim is only a selector: implementations must return their own configured string, never a borrowed token value. Direct and service credentials always use expected_audience instead.
Source§

fn accept_delegated_resource_leaf( &self, ctx: &EnvelopeContext, body: &DecodedRequestBody, ) -> bool

Admit a non-native resource bearer only for a decoded signed request leaf. Default denial preserves every service’s native issuer boundary.
Source§

fn jwt_key_source(&self) -> Option<Arc<dyn JwtKeySource>>

JWT key source for token verification. Read more
Source§

fn build_error_payload(&self, request_id: u64, error: &str) -> Vec<u8> ⓘ

Build a generic error response payload for unexpected errors. Read more
Source§

fn pq_signing_key(&self) -> Option<SigningKey<MlDsa65>>

ML-DSA-65 signing key for the post-quantum half of the response COSE composite (#275). Returning None makes process_request fail closed before dispatch; it never selects an EdDSA-only response. The matching ML-DSA-65 public key must be anchored in the client’s PQ trust store for Hybrid verification to succeed (peer attestation). Read more
Source§

fn verifying_key(&self) -> VerifyingKey

Ed25519 verifying key for envelope signature verification.
Source§

fn require_cnf_binding(&self) -> bool

Whether to reject JWTs that lack a cnf key binding (jwk or jkt). Read more
Source§

fn credential_revocation_store(&self) -> Option<&dyn CredentialRevocationStore>

Credential revocation store for access token revocation. Read more
Source§

fn jwt_verify_policy(&self) -> CryptoPolicy

Fu4/#677: the minimum JWT alg policy enforced in verify_claims. Read more
Source§

fn resolve_key_subject(&self, signer_pubkey: &[u8; 32]) -> Option<Subject>

Resolve a verified signer key to an authorization subject (#446). Read more
Source§

fn cache_key_binding( &self, _verifying_key: VerifyingKey, _subject: &str, _jwt: &str, _expires_at: i64, )

Cache a verified key→subject binding in the trust store. Read more
Source§

fn verify_internal_work_bearer<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, _ctx: &'life1 EnvelopeContext, _token: &'life2 str, _protected: &'life3 ProtectedHeader, ) -> Pin<Box<dyn Future<Output = Result<InternalWorkClaims, Error>> + 'async_trait>>
where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, Self: 'async_trait,

Verify an iw+jwt internal execution work order presented as the direct JWT (single-service Model→Inference boundary, user-approved D5). Read more
Source§

fn verify_claims<'life0, 'life1, 'async_trait>( &'life0 self, ctx: &'life1 mut EnvelopeContext, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait>>
where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,

E2E JWT verification with unified key source. Read more
Source§

impl WorktreeHandler for RegistryService

Source§

fn handle_walk<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, ctx: &'life1 EnvelopeContext, _request_id: u64, repo_id: &'life2 str, name: &'life3 str, data: &'life4 NpWalk, ) -> Pin<Box<dyn Future<Output = Result<RWalk>> + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait,

Walk: resolve path components to get a fid.

Source§

fn handle_open_read<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, ctx: &'life1 EnvelopeContext, request_id: u64, repo_id: &'life2 str, name: &'life3 str, data: &'life4 NpStatReq, ) -> Pin<Box<dyn Future<Output = Result<ROpen>> + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait,

Query-scoped read-only open; the wire request has no mode field.

Source§

fn handle_open<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, ctx: &'life1 EnvelopeContext, _request_id: u64, _repo_id: &'life2 str, _name: &'life3 str, data: &'life4 NpOpen, ) -> Pin<Box<dyn Future<Output = Result<ROpen>> + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait,

Open: open a walked fid for I/O, returns iounit.

Source§

fn handle_create<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, ctx: &'life1 EnvelopeContext, _request_id: u64, repo_id: &'life2 str, name: &'life3 str, data: &'life4 NpCreate, ) -> Pin<Box<dyn Future<Output = Result<ROpen>> + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait,

Create: create a file/dir under a walked directory fid.

Source§

fn handle_read<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, ctx: &'life1 EnvelopeContext, _request_id: u64, repo_id: &'life2 str, name: &'life3 str, data: &'life4 NpRead, ) -> Pin<Box<dyn Future<Output = Result<RRead>> + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait,

Read: offset+count read, bounded by iounit. This is THE fix for the readFile bug — no unbounded allocation possible. For directories, returns entries in wire format: name_len(u32le) + name(utf8) + is_dir(u8) + size(u64le).

Source§

fn handle_write<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, ctx: &'life1 EnvelopeContext, _request_id: u64, _repo_id: &'life2 str, _name: &'life3 str, data: &'life4 NpWrite, ) -> Pin<Box<dyn Future<Output = Result<RWrite>> + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait,

Write: offset+data write, rejects if data > iounit.

Source§

fn handle_clunk<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, ctx: &'life1 EnvelopeContext, _request_id: u64, _repo_id: &'life2 str, _name: &'life3 str, data: &'life4 NpClunk, ) -> Pin<Box<dyn Future<Output = Result<()>> + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait,

Clunk: release a fid, close any open file.

Source§

fn handle_remove<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, ctx: &'life1 EnvelopeContext, _request_id: u64, repo_id: &'life2 str, name: &'life3 str, data: &'life4 NpRemove, ) -> Pin<Box<dyn Future<Output = Result<()>> + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait,

Remove: clunk + delete the file/directory.

Source§

fn handle_np_stat<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, ctx: &'life1 EnvelopeContext, _request_id: u64, _repo_id: &'life2 str, _name: &'life3 str, data: &'life4 NpStatReq, ) -> Pin<Box<dyn Future<Output = Result<RStat>> + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait,

Stat: get file metadata for a fid.

Source§

fn handle_wstat<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, ctx: &'life1 EnvelopeContext, _request_id: u64, _repo_id: &'life2 str, _name: &'life3 str, data: &'life4 NpWstat, ) -> Pin<Box<dyn Future<Output = Result<()>> + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait,

Wstat: modify file metadata (rename, truncate, etc).

Source§

fn handle_flush<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, _ctx: &'life1 EnvelopeContext, _request_id: u64, _repo_id: &'life2 str, _name: &'life3 str, _data: &'life4 NpFlush, ) -> Pin<Box<dyn Future<Output = Result<()>> + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait,

Flush: cancel a pending operation (no-op for synchronous ops).

Source§

fn handle_stage_all<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, _ctx: &'life1 EnvelopeContext, _request_id: u64, repo_id: &'life2 str, name: &'life3 str, ) -> Pin<Box<dyn Future<Output = Result<()>> + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Stage all tracked modified files in this worktree (git add -u).

Source§

fn handle_stage_files<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, _ctx: &'life1 EnvelopeContext, _request_id: u64, repo_id: &'life2 str, name: &'life3 str, data: &'life4 StageFilesRequest, ) -> Pin<Box<dyn Future<Output = Result<()>> + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait,

Stage specific files in this worktree.

Source§

fn handle_stage_all_including_untracked<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, _ctx: &'life1 EnvelopeContext, _request_id: u64, repo_id: &'life2 str, name: &'life3 str, ) -> Pin<Box<dyn Future<Output = Result<()>> + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Stage all files including untracked in this worktree (git add -A).

Source§

fn handle_commit<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, _ctx: &'life1 EnvelopeContext, _request_id: u64, repo_id: &'life2 str, name: &'life3 str, data: &'life4 CommitRequest, ) -> Pin<Box<dyn Future<Output = Result<String>> + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait,

Commit staged changes in this worktree.

Source§

fn handle_commit_with_author<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, _ctx: &'life1 EnvelopeContext, _request_id: u64, repo_id: &'life2 str, name: &'life3 str, data: &'life4 CommitWithAuthorRequest, ) -> Pin<Box<dyn Future<Output = Result<String>> + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait,

Commit staged changes with specified author.

#910a: this is the RPC verb git::promote::promote drives (via WorktreeClient::commit_with_author) to snapshot the promoted upper layer, so publishing the PDS record here — rather than in the client-side advance_pointer stub — is what makes “promote” actually advance the atproto pointer for a local/single-node deployment.

Source§

fn handle_amend_commit<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, _ctx: &'life1 EnvelopeContext, _request_id: u64, repo_id: &'life2 str, name: &'life3 str, data: &'life4 AmendCommitRequest, ) -> Pin<Box<dyn Future<Output = Result<String>> + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait,

Amend the last commit in this worktree.

Source§

fn handle_checkout<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, _ctx: &'life1 EnvelopeContext, _request_id: u64, repo_id: &'life2 str, name: &'life3 str, data: &'life4 CheckoutRequest, ) -> Pin<Box<dyn Future<Output = Result<()>> + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait,

Checkout a ref in this worktree.

Source§

fn handle_merge<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, _ctx: &'life1 EnvelopeContext, _request_id: u64, repo_id: &'life2 str, name: &'life3 str, data: &'life4 MergeRequest, ) -> Pin<Box<dyn Future<Output = Result<()>> + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait,

Merge a branch into this worktree.

Source§

fn handle_abort_merge<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, _ctx: &'life1 EnvelopeContext, _request_id: u64, repo_id: &'life2 str, name: &'life3 str, ) -> Pin<Box<dyn Future<Output = Result<()>> + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Abort an in-progress merge in this worktree.

Source§

fn handle_continue_merge<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, _ctx: &'life1 EnvelopeContext, _request_id: u64, repo_id: &'life2 str, name: &'life3 str, data: &'life4 ContinueMergeRequest, ) -> Pin<Box<dyn Future<Output = Result<()>> + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait,

Continue a merge after resolving conflicts.

Source§

fn handle_quit_merge<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, _ctx: &'life1 EnvelopeContext, _request_id: u64, repo_id: &'life2 str, name: &'life3 str, ) -> Pin<Box<dyn Future<Output = Result<()>> + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Exit merge state without committing.

Auto Trait Implementations§

Blanket Implementations§

Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
§

impl<T> Any for T
where T: Any,

§

fn into_any(self: Box<T>) -> Box<dyn Any>

§

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

§

fn type_name(&self) -> &'static str

§

impl<T> AnySync for T
where T: Any + Send + Sync,

§

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Sync + Send> ⓘ

§

impl<'a, T, E> AsTaggedExplicit<'a, E> for T
where T: 'a,

§

fn explicit(self, class: Class, tag: u32) -> TaggedParser<'a, Explicit, Self, E>

§

impl<'a, T, E> AsTaggedImplicit<'a, E> for T
where T: 'a,

§

fn implicit( self, class: Class, constructed: bool, tag: u32, ) -> TaggedParser<'a, Implicit, Self, E>

Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

§

impl<T> FutureExt for T

§

fn with_context(self, otel_cx: Context) -> WithContext<Self>

Attaches the provided Context to this type, returning a WithContext wrapper. Read more
§

fn with_current_context(self) -> WithContext<Self>

Attaches the current Context to this type, returning a WithContext wrapper. Read more
§

impl<T, W> HasTypeWitness<W> for T
where W: MakeTypeWitness<Arg = T>, T: ?Sized,

§

const WITNESS: W = W::MAKE

A constant of the type witness
§

impl<T> Identity for T
where T: ?Sized,

§

const TYPE_EQ: TypeEq<T, <T as Identity>::Type> = TypeEq::NEW

Proof that Self is the same type as Self::Type, provides methods for casting between Self and Self::Type.
§

type Type = T

The same type as Self, used to emulate type equality bounds (T == U) with associated type equality constraints (T: Identity<Type = U>).
§

impl<T> Instrument for T

§

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided [Span], returning an Instrumented wrapper. Read more
§

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an Instrumented wrapper. Read more
Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<T> IntoEither for T

Source§

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> if into_left is true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
Source§

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
Source§

impl<T> IntoRequest<T> for T

Source§

fn into_request(self) -> Request<T>

Wrap the input message T in a tonic::Request
§

impl<T> JaggedSlice<T> for T

§

type Index = Index2

§

fn push_into(self, array: &mut Jagged<T>)

§

fn insert_into(self, index: <T as JaggedSlice<T>>::Index, array: &mut Jagged<T>)

§

impl<T> Pointable for T

§

const ALIGN: usize

The alignment of pointer.
§

type Init = T

The type for initializers.
§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
§

impl<T> PolicyExt for T
where T: ?Sized,

§

fn and<P, B, E>(self, other: P) -> And<T, P>
where T: Policy<B, E>, P: Policy<B, E>,

Create a new Policy that returns [Action::Follow] only if self and other return Action::Follow. Read more
§

fn or<P, B, E>(self, other: P) -> Or<T, P>
where T: Policy<B, E>, P: Policy<B, E>,

Create a new Policy that returns [Action::Follow] if either self or other returns Action::Follow. Read more
Source§

impl<T> Same for T

Source§

type Output = T

Should always be Self
§

impl<T> ServiceExt for T

§

fn map_response_body<F>(self, f: F) -> MapResponseBody<Self, F>
where Self: Sized,

Apply a transformation to the response body. Read more
§

fn trace_for_http(self) -> Trace<Self, SharedClassifier<ServerErrorsAsFailures>>
where Self: Sized,

High level tracing that classifies responses using HTTP status codes. Read more
§

fn trace_for_grpc(self) -> Trace<Self, SharedClassifier<GrpcErrorsAsFailures>>
where Self: Sized,

High level tracing that classifies responses using gRPC headers. Read more
§

fn follow_redirects(self) -> FollowRedirect<Self>
where Self: Sized,

Follow redirect resposes using the Standard policy. Read more
Source§

impl<S> Spawnable for S
where S: RequestService + Send + Sync,

Source§

fn name(&self) -> &str

Service name (for logging and registry).
Source§

fn registrations(&self) -> Vec<(SocketKind, TransportConfig)>

Endpoints to register with EndpointRegistry. Read more
Source§

fn run( self: Box<S>, shutdown: Arc<Notify>, on_ready: Option<Sender<()>>, ) -> Result<(), RpcError>

Run the service on current thread (blocking). Read more
Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = Infallible

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

§

fn vzip(self) -> V

§

impl<T> WithSubscriber for T

§

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a [WithDispatch] wrapper. Read more
§

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a [WithDispatch] wrapper. Read more
§

impl<T> ErasedDestructor for T
where T: 'static,

§

impl<T> MaybeSend for T
where T: Send,

§

impl<T> MaybeSend for T
where T: Send,

§

impl<T> MaybeSync for T
where T: Sync,

§

impl<T> MaybeSync for T
where T: Sync,