taskflow_rs/executor/handlers/
http.rs

1use async_trait::async_trait;
2use reqwest;
3use std::collections::HashMap;
4
5use crate::TaskResult;
6use crate::error::{Result, TaskFlowError};
7use crate::task::{Task, TaskHandler};
8
9pub struct HttpTaskHandler {
10    client: reqwest::Client,
11}
12
13impl HttpTaskHandler {
14    pub fn new() -> Self {
15        Self {
16            client: reqwest::Client::new(),
17        }
18    }
19}
20
21#[async_trait]
22impl TaskHandler for HttpTaskHandler {
23    async fn execute(&self, task: &Task) -> Result<TaskResult> {
24        let start_time = std::time::Instant::now();
25
26        let url = task
27            .definition
28            .payload
29            .get("url")
30            .and_then(|v| v.as_str())
31            .ok_or_else(|| {
32                TaskFlowError::InvalidConfiguration("Missing 'url' in payload".to_string())
33            })?;
34
35        let method = task
36            .definition
37            .payload
38            .get("method")
39            .and_then(|v| v.as_str())
40            .unwrap_or("GET");
41
42        let response = match method.to_uppercase().as_str() {
43            "GET" => self.client.get(url).send().await?,
44            "POST" => {
45                let mut request = self.client.post(url);
46                if let Some(body) = task.definition.payload.get("body") {
47                    request = request.json(body);
48                }
49                request.send().await?
50            }
51            _ => {
52                return Err(TaskFlowError::InvalidConfiguration(format!(
53                    "Unsupported HTTP method: {}",
54                    method
55                )));
56            }
57        };
58
59        let status = response.status();
60        let body = response.text().await?;
61        let execution_time = start_time.elapsed().as_millis() as u64;
62
63        let success = status.is_success();
64        let mut metadata = HashMap::new();
65        metadata.insert("status_code".to_string(), status.as_u16().to_string());
66        metadata.insert("method".to_string(), method.to_string());
67
68        Ok(TaskResult {
69            success,
70            output: Some(body),
71            error: if success {
72                None
73            } else {
74                Some(format!("HTTP {}", status))
75            },
76            execution_time_ms: execution_time,
77            metadata,
78        })
79    }
80
81    fn task_type(&self) -> &str {
82        "http_request"
83    }
84}