feagi-agent 0.0.1

Client library for building FEAGI agents in Rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94

use crate::FeagiAgentError;
use feagi_io::traits_and_enums::client::{FeagiClientPusher, FeagiClientPusherProperties};
use feagi_io::traits_and_enums::shared::FeagiEndpointState;
use feagi_io::AgentID;
use feagi_serialization::FeagiByteContainer;

#[allow(dead_code)]
pub struct SensorAgent {
    properties: Box<dyn FeagiClientPusherProperties>,
    pusher: Option<Box<dyn FeagiClientPusher>>,
}

#[allow(dead_code)]
impl SensorAgent {
    pub fn new(properties: Box<dyn FeagiClientPusherProperties>, agent_id: AgentID) -> SensorAgent {
        let mut buffer = FeagiByteContainer::new_empty();
        let _ = buffer.set_agent_identifier(agent_id);

        SensorAgent {
            properties,
            pusher: None,
        }
    }

    pub fn request_connect(&mut self) -> Result<(), FeagiAgentError> {
        if self.pusher.is_none() {
            self.pusher = Some(self.properties.as_boxed_client_pusher());
        }

        let pusher = self.pusher.as_mut().unwrap();

        match pusher.poll() {
            FeagiEndpointState::Inactive => {
                pusher.request_connect()?;
                Ok(())
            }
            _ => Err(FeagiAgentError::ConnectionFailed(
                "Socket is already active!".to_string(),
            )),
        }
    }

    pub fn send_buffer(&mut self, buffer: &FeagiByteContainer) -> Result<(), FeagiAgentError> {
        let pusher = self.pusher.as_mut().ok_or_else(|| {
            FeagiAgentError::ConnectionFailed("No socket is active to poll!".to_string())
        })?;

        let state_snapshot = pusher.poll().clone();
        match state_snapshot {
            FeagiEndpointState::Inactive => Err(FeagiAgentError::UnableToSendData(
                "Cannot send to inactive socket".to_string(),
            )),
            FeagiEndpointState::Pending => Err(FeagiAgentError::UnableToSendData(
                "Cannot send to pending socket".to_string(),
            )),
            FeagiEndpointState::ActiveWaiting => {
                pusher.publish_data(buffer.get_byte_ref())?;
                Ok(())
            }
            FeagiEndpointState::ActiveHasData => Err(FeagiAgentError::UnableToSendData(
                "Socket has data!".to_string(),
            )),
            FeagiEndpointState::Errored(err) => {
                pusher.confirm_error_and_close()?;
                Err(FeagiAgentError::ConnectionFailed(err.to_string()))
            }
        }
    }

    pub fn poll(&mut self) -> Result<(), FeagiAgentError> {
        let pusher = self.pusher.as_mut().ok_or_else(|| {
            FeagiAgentError::ConnectionFailed("No socket is active to poll!".to_string())
        })?;

        let state = pusher.poll().clone();
        match state {
            FeagiEndpointState::Inactive => Ok(()),
            FeagiEndpointState::Pending => Ok(()),
            FeagiEndpointState::ActiveWaiting => {
                // Do nothing
                Ok(())
            }
            FeagiEndpointState::ActiveHasData => Err(FeagiAgentError::UnableToSendData(
                "Sensor Socket has recieved data!".to_string(),
            )),
            FeagiEndpointState::Errored(_) => {
                pusher.confirm_error_and_close()?;
                Err(FeagiAgentError::ConnectionFailed(
                    "Connection failed".to_string(),
                ))
            }
        }
    }
}