Struct PluginServiceClient

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

Implementations

impl PluginServiceClient<Channel>

pub async fn connect<D>(dst: D) -> Result<Self, Error>

where D: TryInto<Endpoint>, D::Error: Into<StdError>,

Attempt to create a new client by connecting to a given endpoint.

impl<T> PluginServiceClient<T>

where T: GrpcService<BoxBody>, T::Error: Into<StdError>, T::ResponseBody: Body<Data = Bytes> + Send + 'static, <T::ResponseBody as Body>::Error: Into<StdError> + Send,

pub fn new(inner: T) -> Self

pub fn with_origin(inner: T, origin: Uri) -> Self

pub fn with_interceptor<F>( inner: T, interceptor: F, ) -> PluginServiceClient<InterceptedService<T, F>>

where F: Interceptor, T::ResponseBody: Default, T: Service<Request<BoxBody>, Response = Response<<T as GrpcService<BoxBody>>::ResponseBody>>, <T as Service<Request<BoxBody>>>::Error: Into<StdError> + Send + Sync,

pub fn send_compressed(self, encoding: CompressionEncoding) -> Self

Compress requests with the given encoding.

This requires the server to support it otherwise it might respond with an error.

pub fn accept_compressed(self, encoding: CompressionEncoding) -> Self

Enable decompressing responses.

pub fn max_decoding_message_size(self, limit: usize) -> Self

Limits the maximum size of a decoded message.

Default: 4MB

pub fn max_encoding_message_size(self, limit: usize) -> Self

Limits the maximum size of an encoded message.

Default: usize::MAX

pub async fn get_query_schemas( &mut self, request: impl IntoRequest<GetQuerySchemasRequest>, ) -> Result<Response<Streaming<GetQuerySchemasResponse>>, Status>

Get schemas for all supported queries by the plugin.

This is used by Hipcheck to validate that:

• The plugin supports a default query taking a target type if used as a top-level plugin in the user’s policy file.
• That requests sent to the plugin and data returned by the plugin match the schema during execution.

pub async fn set_configuration( &mut self, request: impl IntoRequest<SetConfigurationRequest>, ) -> Result<Response<SetConfigurationResponse>, Status>

Hipcheck sends all child nodes for the plugin from the user’s policy file to configure the plugin.

pub async fn get_default_policy_expression( &mut self, request: impl IntoRequest<GetDefaultPolicyExpressionRequest>, ) -> Result<Response<GetDefaultPolicyExpressionResponse>, Status>

Get the default policy for a plugin, which may additionally depend on the plugin’s configuration.

pub async fn explain_default_query( &mut self, request: impl IntoRequest<ExplainDefaultQueryRequest>, ) -> Result<Response<ExplainDefaultQueryResponse>, Status>

Get an explanation of what the default query returns, to use when reporting analysis results to users.

Note that, because users can specify their own policy expression, this explanation should not assume the user has used the default policy expression, if one is provided by the plugin.

pub async fn initiate_query_protocol( &mut self, request: impl IntoStreamingRequest<Message = InitiateQueryProtocolRequest>, ) -> Result<Response<Streaming<InitiateQueryProtocolResponse>>, Status>

Open a bidirectional streaming RPC to enable a request/response protocol between Hipcheck and a plugin, where Hipcheck can issue queries to the plugin, and the plugin may issue queries to other plugins through Hipcheck.

Queries are cached by the publisher name, plugin name, query name, and key, and if a match is found for those four values, then Hipcheck will respond with the cached result of that prior matching query rather than running the query again.

Trait Implementations

impl<T: Clone> Clone for PluginServiceClient<T>

fn clone(&self) -> PluginServiceClient<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for PluginServiceClient<T>

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

Formats the value using the given formatter.