Skip to main content

FileProcessingStepHandler

backbone_bucket::application::workflows

Trait FileProcessingStepHandler 

Source 
pub trait FileProcessingStepHandler: Send + Sync {

Show 43 methods    // Required methods
    fn handle_load_job<'life0, 'life1, 'async_trait>(
        &'life0 self,
        instance: &'life1 mut FileProcessingFlowInstance,
    ) -> Pin<Box<dyn Future<Output = Result<Option<FileProcessingFlowStep>, FlowError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn handle_mark_running<'life0, 'life1, 'async_trait>(
        &'life0 self,
        instance: &'life1 mut FileProcessingFlowInstance,
    ) -> Pin<Box<dyn Future<Output = Result<Option<FileProcessingFlowStep>, FlowError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn handle_load_file<'life0, 'life1, 'async_trait>(
        &'life0 self,
        instance: &'life1 mut FileProcessingFlowInstance,
    ) -> Pin<Box<dyn Future<Output = Result<Option<FileProcessingFlowStep>, FlowError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn handle_load_bucket<'life0, 'life1, 'async_trait>(
        &'life0 self,
        instance: &'life1 mut FileProcessingFlowInstance,
    ) -> Pin<Box<dyn Future<Output = Result<Option<FileProcessingFlowStep>, FlowError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn evaluate_route_by_job_type<'life0, 'life1, 'async_trait>(
        &'life0 self,
        instance: &'life1 FileProcessingFlowInstance,
    ) -> Pin<Box<dyn Future<Output = Result<FileProcessingFlowStep, FlowError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn handle_process_image_thumbnail<'life0, 'life1, 'async_trait>(
        &'life0 self,
        instance: &'life1 mut FileProcessingFlowInstance,
    ) -> Pin<Box<dyn Future<Output = Result<Option<FileProcessingFlowStep>, FlowError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn handle_store_image_thumbnail<'life0, 'life1, 'async_trait>(
        &'life0 self,
        instance: &'life1 mut FileProcessingFlowInstance,
    ) -> Pin<Box<dyn Future<Output = Result<Option<FileProcessingFlowStep>, FlowError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn handle_update_file_thumbnail<'life0, 'life1, 'async_trait>(
        &'life0 self,
        instance: &'life1 mut FileProcessingFlowInstance,
    ) -> Pin<Box<dyn Future<Output = Result<Option<FileProcessingFlowStep>, FlowError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn handle_process_video_thumbnail<'life0, 'life1, 'async_trait>(
        &'life0 self,
        instance: &'life1 mut FileProcessingFlowInstance,
    ) -> Pin<Box<dyn Future<Output = Result<Option<FileProcessingFlowStep>, FlowError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn handle_store_video_thumbnail<'life0, 'life1, 'async_trait>(
        &'life0 self,
        instance: &'life1 mut FileProcessingFlowInstance,
    ) -> Pin<Box<dyn Future<Output = Result<Option<FileProcessingFlowStep>, FlowError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn handle_update_file_video_thumbnail<'life0, 'life1, 'async_trait>(
        &'life0 self,
        instance: &'life1 mut FileProcessingFlowInstance,
    ) -> Pin<Box<dyn Future<Output = Result<Option<FileProcessingFlowStep>, FlowError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn handle_process_document_preview<'life0, 'life1, 'async_trait>(
        &'life0 self,
        instance: &'life1 mut FileProcessingFlowInstance,
    ) -> Pin<Box<dyn Future<Output = Result<Option<FileProcessingFlowStep>, FlowError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn handle_store_document_preview<'life0, 'life1, 'async_trait>(
        &'life0 self,
        instance: &'life1 mut FileProcessingFlowInstance,
    ) -> Pin<Box<dyn Future<Output = Result<Option<FileProcessingFlowStep>, FlowError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn handle_update_file_document_preview<'life0, 'life1, 'async_trait>(
        &'life0 self,
        instance: &'life1 mut FileProcessingFlowInstance,
    ) -> Pin<Box<dyn Future<Output = Result<Option<FileProcessingFlowStep>, FlowError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn handle_process_compression<'life0, 'life1, 'async_trait>(
        &'life0 self,
        instance: &'life1 mut FileProcessingFlowInstance,
    ) -> Pin<Box<dyn Future<Output = Result<Option<FileProcessingFlowStep>, FlowError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn handle_store_compressed_file<'life0, 'life1, 'async_trait>(
        &'life0 self,
        instance: &'life1 mut FileProcessingFlowInstance,
    ) -> Pin<Box<dyn Future<Output = Result<Option<FileProcessingFlowStep>, FlowError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn handle_update_file_compression<'life0, 'life1, 'async_trait>(
        &'life0 self,
        instance: &'life1 mut FileProcessingFlowInstance,
    ) -> Pin<Box<dyn Future<Output = Result<Option<FileProcessingFlowStep>, FlowError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn handle_update_bucket_compression_stats<'life0, 'life1, 'async_trait>(
        &'life0 self,
        instance: &'life1 mut FileProcessingFlowInstance,
    ) -> Pin<Box<dyn Future<Output = Result<Option<FileProcessingFlowStep>, FlowError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn handle_process_virus_scan<'life0, 'life1, 'async_trait>(
        &'life0 self,
        instance: &'life1 mut FileProcessingFlowInstance,
    ) -> Pin<Box<dyn Future<Output = Result<Option<FileProcessingFlowStep>, FlowError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn evaluate_check_threat_level<'life0, 'life1, 'async_trait>(
        &'life0 self,
        instance: &'life1 FileProcessingFlowInstance,
    ) -> Pin<Box<dyn Future<Output = Result<FileProcessingFlowStep, FlowError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn handle_update_scan_safe<'life0, 'life1, 'async_trait>(
        &'life0 self,
        instance: &'life1 mut FileProcessingFlowInstance,
    ) -> Pin<Box<dyn Future<Output = Result<Option<FileProcessingFlowStep>, FlowError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn handle_update_scan_warning<'life0, 'life1, 'async_trait>(
        &'life0 self,
        instance: &'life1 mut FileProcessingFlowInstance,
    ) -> Pin<Box<dyn Future<Output = Result<Option<FileProcessingFlowStep>, FlowError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn handle_notify_scan_warning<'life0, 'life1, 'async_trait>(
        &'life0 self,
        instance: &'life1 mut FileProcessingFlowInstance,
    ) -> Pin<Box<dyn Future<Output = Result<Option<FileProcessingFlowStep>, FlowError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn handle_update_scan_threat<'life0, 'life1, 'async_trait>(
        &'life0 self,
        instance: &'life1 mut FileProcessingFlowInstance,
    ) -> Pin<Box<dyn Future<Output = Result<Option<FileProcessingFlowStep>, FlowError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn handle_notify_threat_detected<'life0, 'life1, 'async_trait>(
        &'life0 self,
        instance: &'life1 mut FileProcessingFlowInstance,
    ) -> Pin<Box<dyn Future<Output = Result<Option<FileProcessingFlowStep>, FlowError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn handle_process_deduplication<'life0, 'life1, 'async_trait>(
        &'life0 self,
        instance: &'life1 mut FileProcessingFlowInstance,
    ) -> Pin<Box<dyn Future<Output = Result<Option<FileProcessingFlowStep>, FlowError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn handle_check_existing_hash<'life0, 'life1, 'async_trait>(
        &'life0 self,
        instance: &'life1 mut FileProcessingFlowInstance,
    ) -> Pin<Box<dyn Future<Output = Result<Option<FileProcessingFlowStep>, FlowError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn handle_update_existing_hash<'life0, 'life1, 'async_trait>(
        &'life0 self,
        instance: &'life1 mut FileProcessingFlowInstance,
    ) -> Pin<Box<dyn Future<Output = Result<Option<FileProcessingFlowStep>, FlowError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn handle_link_file_hash<'life0, 'life1, 'async_trait>(
        &'life0 self,
        instance: &'life1 mut FileProcessingFlowInstance,
    ) -> Pin<Box<dyn Future<Output = Result<Option<FileProcessingFlowStep>, FlowError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn handle_create_new_hash<'life0, 'life1, 'async_trait>(
        &'life0 self,
        instance: &'life1 mut FileProcessingFlowInstance,
    ) -> Pin<Box<dyn Future<Output = Result<Option<FileProcessingFlowStep>, FlowError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn handle_mark_complete<'life0, 'life1, 'async_trait>(
        &'life0 self,
        instance: &'life1 mut FileProcessingFlowInstance,
    ) -> Pin<Box<dyn Future<Output = Result<Option<FileProcessingFlowStep>, FlowError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn handle_emit_complete_event<'life0, 'life1, 'async_trait>(
        &'life0 self,
        instance: &'life1 mut FileProcessingFlowInstance,
    ) -> Pin<Box<dyn Future<Output = Result<Option<FileProcessingFlowStep>, FlowError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn handle_complete<'life0, 'life1, 'async_trait>(
        &'life0 self,
        instance: &'life1 mut FileProcessingFlowInstance,
    ) -> Pin<Box<dyn Future<Output = Result<(), FlowError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn evaluate_retry_or_fail<'life0, 'life1, 'async_trait>(
        &'life0 self,
        instance: &'life1 FileProcessingFlowInstance,
    ) -> Pin<Box<dyn Future<Output = Result<FileProcessingFlowStep, FlowError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn handle_schedule_retry<'life0, 'life1, 'async_trait>(
        &'life0 self,
        instance: &'life1 mut FileProcessingFlowInstance,
    ) -> Pin<Box<dyn Future<Output = Result<Option<FileProcessingFlowStep>, FlowError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn handle_retry_terminal<'life0, 'life1, 'async_trait>(
        &'life0 self,
        instance: &'life1 mut FileProcessingFlowInstance,
    ) -> Pin<Box<dyn Future<Output = Result<(), FlowError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn handle_mark_failed<'life0, 'life1, 'async_trait>(
        &'life0 self,
        instance: &'life1 mut FileProcessingFlowInstance,
    ) -> Pin<Box<dyn Future<Output = Result<Option<FileProcessingFlowStep>, FlowError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn handle_emit_failed_event<'life0, 'life1, 'async_trait>(
        &'life0 self,
        instance: &'life1 mut FileProcessingFlowInstance,
    ) -> Pin<Box<dyn Future<Output = Result<Option<FileProcessingFlowStep>, FlowError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn handle_failed_terminal<'life0, 'life1, 'async_trait>(
        &'life0 self,
        instance: &'life1 mut FileProcessingFlowInstance,
    ) -> Pin<Box<dyn Future<Output = Result<(), FlowError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn handle_job_not_found<'life0, 'life1, 'async_trait>(
        &'life0 self,
        instance: &'life1 mut FileProcessingFlowInstance,
    ) -> Pin<Box<dyn Future<Output = Result<(), FlowError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn handle_file_not_found<'life0, 'life1, 'async_trait>(
        &'life0 self,
        instance: &'life1 mut FileProcessingFlowInstance,
    ) -> Pin<Box<dyn Future<Output = Result<(), FlowError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn handle_unknown_job_type<'life0, 'life1, 'async_trait>(
        &'life0 self,
        instance: &'life1 mut FileProcessingFlowInstance,
    ) -> Pin<Box<dyn Future<Output = Result<(), FlowError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn compensate<'life0, 'life1, 'async_trait>(
        &'life0 self,
        instance: &'life1 mut FileProcessingFlowInstance,
    ) -> Pin<Box<dyn Future<Output = Result<(), FlowError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;

}
Expand description

Step handler trait for FileProcessing flow

Required Methods§

Source

fn handle_load_job<'life0, 'life1, 'async_trait>( &'life0 self, instance: &'life1 mut FileProcessingFlowInstance, ) -> Pin<Box<dyn Future<Output = Result<Option<FileProcessingFlowStep>, FlowError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Handle load_job step

Source

fn handle_mark_running<'life0, 'life1, 'async_trait>( &'life0 self, instance: &'life1 mut FileProcessingFlowInstance, ) -> Pin<Box<dyn Future<Output = Result<Option<FileProcessingFlowStep>, FlowError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Handle mark_running step

Source

fn handle_load_file<'life0, 'life1, 'async_trait>( &'life0 self, instance: &'life1 mut FileProcessingFlowInstance, ) -> Pin<Box<dyn Future<Output = Result<Option<FileProcessingFlowStep>, FlowError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Handle load_file step

Source

fn handle_load_bucket<'life0, 'life1, 'async_trait>( &'life0 self, instance: &'life1 mut FileProcessingFlowInstance, ) -> Pin<Box<dyn Future<Output = Result<Option<FileProcessingFlowStep>, FlowError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Handle load_bucket step

Source

fn evaluate_route_by_job_type<'life0, 'life1, 'async_trait>( &'life0 self, instance: &'life1 FileProcessingFlowInstance, ) -> Pin<Box<dyn Future<Output = Result<FileProcessingFlowStep, FlowError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Evaluate condition for route_by_job_type step

Source

fn handle_process_image_thumbnail<'life0, 'life1, 'async_trait>( &'life0 self, instance: &'life1 mut FileProcessingFlowInstance, ) -> Pin<Box<dyn Future<Output = Result<Option<FileProcessingFlowStep>, FlowError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Handle process_image_thumbnail step

Source

fn handle_store_image_thumbnail<'life0, 'life1, 'async_trait>( &'life0 self, instance: &'life1 mut FileProcessingFlowInstance, ) -> Pin<Box<dyn Future<Output = Result<Option<FileProcessingFlowStep>, FlowError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Handle store_image_thumbnail step

Source

fn handle_update_file_thumbnail<'life0, 'life1, 'async_trait>( &'life0 self, instance: &'life1 mut FileProcessingFlowInstance, ) -> Pin<Box<dyn Future<Output = Result<Option<FileProcessingFlowStep>, FlowError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Handle update_file_thumbnail step

Source

fn handle_process_video_thumbnail<'life0, 'life1, 'async_trait>( &'life0 self, instance: &'life1 mut FileProcessingFlowInstance, ) -> Pin<Box<dyn Future<Output = Result<Option<FileProcessingFlowStep>, FlowError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Handle process_video_thumbnail step

Source

fn handle_store_video_thumbnail<'life0, 'life1, 'async_trait>( &'life0 self, instance: &'life1 mut FileProcessingFlowInstance, ) -> Pin<Box<dyn Future<Output = Result<Option<FileProcessingFlowStep>, FlowError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Handle store_video_thumbnail step

Source

fn handle_update_file_video_thumbnail<'life0, 'life1, 'async_trait>( &'life0 self, instance: &'life1 mut FileProcessingFlowInstance, ) -> Pin<Box<dyn Future<Output = Result<Option<FileProcessingFlowStep>, FlowError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Handle update_file_video_thumbnail step

Source

fn handle_process_document_preview<'life0, 'life1, 'async_trait>( &'life0 self, instance: &'life1 mut FileProcessingFlowInstance, ) -> Pin<Box<dyn Future<Output = Result<Option<FileProcessingFlowStep>, FlowError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Handle process_document_preview step

Source

fn handle_store_document_preview<'life0, 'life1, 'async_trait>( &'life0 self, instance: &'life1 mut FileProcessingFlowInstance, ) -> Pin<Box<dyn Future<Output = Result<Option<FileProcessingFlowStep>, FlowError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Handle store_document_preview step

Source

fn handle_update_file_document_preview<'life0, 'life1, 'async_trait>( &'life0 self, instance: &'life1 mut FileProcessingFlowInstance, ) -> Pin<Box<dyn Future<Output = Result<Option<FileProcessingFlowStep>, FlowError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Handle update_file_document_preview step

Source

fn handle_process_compression<'life0, 'life1, 'async_trait>( &'life0 self, instance: &'life1 mut FileProcessingFlowInstance, ) -> Pin<Box<dyn Future<Output = Result<Option<FileProcessingFlowStep>, FlowError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Handle process_compression step

Source

fn handle_store_compressed_file<'life0, 'life1, 'async_trait>( &'life0 self, instance: &'life1 mut FileProcessingFlowInstance, ) -> Pin<Box<dyn Future<Output = Result<Option<FileProcessingFlowStep>, FlowError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Handle store_compressed_file step

Source

fn handle_update_file_compression<'life0, 'life1, 'async_trait>( &'life0 self, instance: &'life1 mut FileProcessingFlowInstance, ) -> Pin<Box<dyn Future<Output = Result<Option<FileProcessingFlowStep>, FlowError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Handle update_file_compression step

Source

fn handle_update_bucket_compression_stats<'life0, 'life1, 'async_trait>( &'life0 self, instance: &'life1 mut FileProcessingFlowInstance, ) -> Pin<Box<dyn Future<Output = Result<Option<FileProcessingFlowStep>, FlowError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Handle update_bucket_compression_stats step

Source

fn handle_process_virus_scan<'life0, 'life1, 'async_trait>( &'life0 self, instance: &'life1 mut FileProcessingFlowInstance, ) -> Pin<Box<dyn Future<Output = Result<Option<FileProcessingFlowStep>, FlowError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Handle process_virus_scan step

Source

fn evaluate_check_threat_level<'life0, 'life1, 'async_trait>( &'life0 self, instance: &'life1 FileProcessingFlowInstance, ) -> Pin<Box<dyn Future<Output = Result<FileProcessingFlowStep, FlowError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Evaluate condition for check_threat_level step

Source

fn handle_update_scan_safe<'life0, 'life1, 'async_trait>( &'life0 self, instance: &'life1 mut FileProcessingFlowInstance, ) -> Pin<Box<dyn Future<Output = Result<Option<FileProcessingFlowStep>, FlowError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Handle update_scan_safe step

Source

fn handle_update_scan_warning<'life0, 'life1, 'async_trait>( &'life0 self, instance: &'life1 mut FileProcessingFlowInstance, ) -> Pin<Box<dyn Future<Output = Result<Option<FileProcessingFlowStep>, FlowError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Handle update_scan_warning step

Source

fn handle_notify_scan_warning<'life0, 'life1, 'async_trait>( &'life0 self, instance: &'life1 mut FileProcessingFlowInstance, ) -> Pin<Box<dyn Future<Output = Result<Option<FileProcessingFlowStep>, FlowError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Handle notify_scan_warning step

Source

fn handle_update_scan_threat<'life0, 'life1, 'async_trait>( &'life0 self, instance: &'life1 mut FileProcessingFlowInstance, ) -> Pin<Box<dyn Future<Output = Result<Option<FileProcessingFlowStep>, FlowError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Handle update_scan_threat step

Source

fn handle_notify_threat_detected<'life0, 'life1, 'async_trait>( &'life0 self, instance: &'life1 mut FileProcessingFlowInstance, ) -> Pin<Box<dyn Future<Output = Result<Option<FileProcessingFlowStep>, FlowError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Handle notify_threat_detected step

Source

fn handle_process_deduplication<'life0, 'life1, 'async_trait>( &'life0 self, instance: &'life1 mut FileProcessingFlowInstance, ) -> Pin<Box<dyn Future<Output = Result<Option<FileProcessingFlowStep>, FlowError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Handle process_deduplication step

Source

fn handle_check_existing_hash<'life0, 'life1, 'async_trait>( &'life0 self, instance: &'life1 mut FileProcessingFlowInstance, ) -> Pin<Box<dyn Future<Output = Result<Option<FileProcessingFlowStep>, FlowError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Handle check_existing_hash step

Source

fn handle_update_existing_hash<'life0, 'life1, 'async_trait>( &'life0 self, instance: &'life1 mut FileProcessingFlowInstance, ) -> Pin<Box<dyn Future<Output = Result<Option<FileProcessingFlowStep>, FlowError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Handle update_existing_hash step

Handle link_file_hash step

Source

fn handle_create_new_hash<'life0, 'life1, 'async_trait>( &'life0 self, instance: &'life1 mut FileProcessingFlowInstance, ) -> Pin<Box<dyn Future<Output = Result<Option<FileProcessingFlowStep>, FlowError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Handle create_new_hash step

Source

fn handle_mark_complete<'life0, 'life1, 'async_trait>( &'life0 self, instance: &'life1 mut FileProcessingFlowInstance, ) -> Pin<Box<dyn Future<Output = Result<Option<FileProcessingFlowStep>, FlowError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Handle mark_complete step

Source

fn handle_emit_complete_event<'life0, 'life1, 'async_trait>( &'life0 self, instance: &'life1 mut FileProcessingFlowInstance, ) -> Pin<Box<dyn Future<Output = Result<Option<FileProcessingFlowStep>, FlowError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Handle emit_complete_event step

Source

fn handle_complete<'life0, 'life1, 'async_trait>( &'life0 self, instance: &'life1 mut FileProcessingFlowInstance, ) -> Pin<Box<dyn Future<Output = Result<(), FlowError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Handle terminal step complete

Source

fn evaluate_retry_or_fail<'life0, 'life1, 'async_trait>( &'life0 self, instance: &'life1 FileProcessingFlowInstance, ) -> Pin<Box<dyn Future<Output = Result<FileProcessingFlowStep, FlowError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Evaluate condition for retry_or_fail step

Source

fn handle_schedule_retry<'life0, 'life1, 'async_trait>( &'life0 self, instance: &'life1 mut FileProcessingFlowInstance, ) -> Pin<Box<dyn Future<Output = Result<Option<FileProcessingFlowStep>, FlowError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Handle schedule_retry step

Source

fn handle_retry_terminal<'life0, 'life1, 'async_trait>( &'life0 self, instance: &'life1 mut FileProcessingFlowInstance, ) -> Pin<Box<dyn Future<Output = Result<(), FlowError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Handle terminal step retry_terminal

Source

fn handle_mark_failed<'life0, 'life1, 'async_trait>( &'life0 self, instance: &'life1 mut FileProcessingFlowInstance, ) -> Pin<Box<dyn Future<Output = Result<Option<FileProcessingFlowStep>, FlowError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Handle mark_failed step

Source

fn handle_emit_failed_event<'life0, 'life1, 'async_trait>( &'life0 self, instance: &'life1 mut FileProcessingFlowInstance, ) -> Pin<Box<dyn Future<Output = Result<Option<FileProcessingFlowStep>, FlowError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Handle emit_failed_event step

Source

fn handle_failed_terminal<'life0, 'life1, 'async_trait>( &'life0 self, instance: &'life1 mut FileProcessingFlowInstance, ) -> Pin<Box<dyn Future<Output = Result<(), FlowError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Handle terminal step failed_terminal

Source

fn handle_job_not_found<'life0, 'life1, 'async_trait>( &'life0 self, instance: &'life1 mut FileProcessingFlowInstance, ) -> Pin<Box<dyn Future<Output = Result<(), FlowError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Handle terminal step job_not_found

Source

fn handle_file_not_found<'life0, 'life1, 'async_trait>( &'life0 self, instance: &'life1 mut FileProcessingFlowInstance, ) -> Pin<Box<dyn Future<Output = Result<(), FlowError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Handle terminal step file_not_found

Source

fn handle_unknown_job_type<'life0, 'life1, 'async_trait>( &'life0 self, instance: &'life1 mut FileProcessingFlowInstance, ) -> Pin<Box<dyn Future<Output = Result<(), FlowError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Handle terminal step unknown_job_type

Source

fn compensate<'life0, 'life1, 'async_trait>( &'life0 self, instance: &'life1 mut FileProcessingFlowInstance, ) -> Pin<Box<dyn Future<Output = Result<(), FlowError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Execute compensation (rollback)

Dyn Compatibility§

This trait is dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementors§