Struct ManagerProxy

pub struct ManagerProxy { /* private fields */ }

Implementations

impl ManagerProxy

pub fn new(channel: AsyncChannel) -> Self

Create a new Proxy for fuchsia.fuzzer/Manager.

pub fn take_event_stream(&self) -> ManagerEventStream

Get a Stream of events from the remote end of the protocol.

Panics

Panics if the event stream was already taken.

pub fn connect( &self, fuzzer_url: &str, controller: ServerEnd<ControllerMarker>, ) -> QueryResponseFut<ManagerConnectResult, DefaultFuchsiaResourceDialect>

Connects to a fuzzer that implements the fuchsia.fuzzer/Controller protocol.

If the fuzzer is not currently running, the fuzz_manager will first start it (via the test_manager) before proceeding. The fuzz_manager sends the controller on to the fuzz-registry, which contains the ControllerProviders that can fulfill the connection request.

See fuchsia.test.manager/LaunchError for details on ways test_manager can fail.

• request fuzzer_url the package URL for the fuzzer.
• request controller the connection from the client.

• error one of the following:
  • ZX_ERR_NO_RESOURCES if test_manager needs resources that are unavailable.
  • ZX_ERR_NOT_FOUND if the fuzzer URL is not recognized by test_manager.
  • ZX_ERR_INVALID_ARGS if test_manager reports invalid arguments.
  • ZX_ERR_NOT_SUPPORTED if test_manager cannot connect to the test suite.
  • ZX_ERR_INTERNAL if test_manager encountered some other, unspecified failure.
  • ZX_ERR_TIMED_OUT if the fuzzer is not present or added to fuzz-registry after starting.
  • ZX_ERR_SHOULD_WAIT if another fuzzer is still starting.

pub fn get_output( &self, fuzzer_url: &str, output: TestOutput, socket: Socket, ) -> QueryResponseFut<ManagerGetOutputResult, DefaultFuchsiaResourceDialect>

Forwards the fuzzer’s output of the given type to the provided socket.

If this method is called multiple times for the same output type, the socket from the subsequent call replaces the socket from the earlier call, which is closed.

• request fuzzer_url the package URL for the fuzzer.
• request output the type of the output stream to forward.
• request socket a socket to forward the output stream to.

• error one of the following:
  • ZX_ERR_INVALID_ARGS if the URL cannot be parsed.
  • ZX_ERR_NOT_FOUND if the fuzzer URL was not recognized by test_manager.
  • ZX_ERR_BAD_STATE if the fuzzer is not connected.

pub fn stop( &self, fuzzer_url: &str, ) -> QueryResponseFut<ManagerStopResult, DefaultFuchsiaResourceDialect>

Stops the associated fuzzer immediately, ending any workflows in progress.

• request fuzzer_url the package URL for the fuzzer.

• error ZX_ERR_NOT_FOUND if no fuzzer was active with the given URL.

Trait Implementations

impl Clone for ManagerProxy

fn clone(&self) -> ManagerProxy

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ManagerProxy

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

Formats the value using the given formatter.

impl ManagerProxyInterface for ManagerProxy

type ConnectResponseFut = QueryResponseFut<Result<(), i32>>

type GetOutputResponseFut = QueryResponseFut<Result<(), i32>>

type StopResponseFut = QueryResponseFut<Result<(), i32>>

fn connect( &self, fuzzer_url: &str, controller: ServerEnd<ControllerMarker>, ) -> Self::ConnectResponseFut

fn get_output( &self, fuzzer_url: &str, output: TestOutput, socket: Socket, ) -> Self::GetOutputResponseFut

fn stop(&self, fuzzer_url: &str) -> Self::StopResponseFut

impl Proxy for ManagerProxy

type Protocol = ManagerMarker

The protocol which this Proxy controls.

fn from_channel(inner: AsyncChannel) -> Self

Create a proxy over the given channel.

fn into_channel(self) -> Result<AsyncChannel, Self>

Attempt to convert the proxy back into a channel.

fn as_channel(&self) -> &AsyncChannel

Get a reference to the proxy’s underlying channel.

fn into_client_end(self) -> Result<ClientEnd<Self::Protocol>, Self>

Attempt to convert the proxy back into a client end.

fn is_closed(&self) -> bool

Returns true if the proxy has received the PEER_CLOSED signal.

fn on_closed(&self) -> OnSignals<'_, Unowned<'_, Handle>>

Returns a future that completes when the proxy receives the PEER_CLOSED signal.