Method process

crates/lambda-boogie-handler/handler.rs:192–243

(
        &self,
        file_text: String,
        remote_args: Vec<String>,
    )

    }

    pub async fn process(
        &self,
        file_text: String,
        remote_args: Vec<String>,
    ) -> Result<ProverResponse> {
        let hash = Self::generate_hash(&file_text);

        if let Some((out, err, status)) = self.check_cache(&hash).await? {
            return Ok(ProverResponse {
                out,
                err,
                status,
                cached: true,
            });
        }

        let mut temp_file = tempfile::Builder::new()
            .suffix(".bpl")
            .tempfile()
            .context("Failed to create temporary file")?;

        use std::io::Write;
        temp_file
            .write_all(file_text.as_bytes())
            .context("Failed to write to temporary file")?;

        let temp_file_path = temp_file.path().to_string_lossy().to_string();

        let (out, err, status) = match self.execute_boogie(&temp_file_path, remote_args).await {
            Ok(output) => output,
            Err(e) => (
                String::new(),
                format!("Error executing boogie remotely: {}", e),
                -1,
            ),
        };

        if let Err(e) = self.cache_result(&hash, &out, &err, status).await {
            println!("Failed to cache result: {}", e);
        } else {
            println!("Result cached successfully for hash: {}", hash);
        }

        temp_file.close()?;

        Ok(ProverResponse {
            out,
            err,
            status: status,
            cached: false,
        })
    }
}