torc 0.21.0

Workflow management system
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
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164

//! Scheduled compute nodes pagination functionality.
//!
//! This module provides lazy iteration and vector collection support for scheduled compute nodes
//! using the generic pagination framework.

use crate::client::apis;
use crate::client::commands::pagination::base::{
    Paginatable, PaginatedIterator, PaginatedResponse, PaginationParams,
};
use crate::models::ScheduledComputeNodesModel;

/// Parameters for listing scheduled compute nodes with default values and builder methods.
#[derive(Debug, Clone, Default)]
pub struct ScheduledComputeNodeListParams {
    /// Workflow ID to list scheduled compute nodes from
    pub workflow_id: i64,
    /// Pagination offset
    pub offset: i64,
    /// Maximum number of records to return
    pub limit: Option<i64>,
    /// Field to sort by
    pub sort_by: Option<String>,
    /// Reverse sort order
    pub reverse_sort: Option<bool>,
    /// Filter by scheduler ID
    pub scheduler_id: Option<String>,
    /// Filter by scheduler config ID
    pub scheduler_config_id: Option<String>,
    /// Filter by status
    pub status: Option<String>,
}

impl ScheduledComputeNodeListParams {
    pub fn new() -> Self {
        Self::default()
    }

    pub fn with_offset(mut self, offset: i64) -> Self {
        self.offset = offset;
        self
    }

    pub fn with_limit(mut self, limit: i64) -> Self {
        self.limit = Some(limit);
        self
    }

    pub fn with_sort_by(mut self, sort_by: String) -> Self {
        self.sort_by = Some(sort_by);
        self
    }

    pub fn with_reverse_sort(mut self, reverse: bool) -> Self {
        self.reverse_sort = Some(reverse);
        self
    }

    pub fn with_scheduler_id(mut self, scheduler_id: String) -> Self {
        self.scheduler_id = Some(scheduler_id);
        self
    }

    pub fn with_scheduler_config_id(mut self, scheduler_config_id: String) -> Self {
        self.scheduler_config_id = Some(scheduler_config_id);
        self
    }

    pub fn with_status(mut self, status: String) -> Self {
        self.status = Some(status);
        self
    }
}

impl PaginationParams for ScheduledComputeNodeListParams {
    fn offset(&self) -> i64 {
        self.offset
    }

    fn set_offset(&mut self, offset: i64) {
        self.offset = offset;
    }

    fn limit(&self) -> Option<i64> {
        self.limit
    }

    fn sort_by(&self) -> Option<&str> {
        self.sort_by.as_deref()
    }

    fn reverse_sort(&self) -> Option<bool> {
        self.reverse_sort
    }
}

impl Paginatable for ScheduledComputeNodesModel {
    type ListError = apis::default_api::ListScheduledComputeNodesError;
    type Params = ScheduledComputeNodeListParams;

    fn fetch_page(
        config: &apis::configuration::Configuration,
        params: &Self::Params,
        limit: i64,
    ) -> Result<PaginatedResponse<Self>, apis::Error<Self::ListError>> {
        let response = apis::default_api::list_scheduled_compute_nodes(
            config,
            params.workflow_id,
            Some(params.offset),
            Some(limit),
            params.sort_by.as_deref(),
            params.reverse_sort,
            params.scheduler_id.as_deref(),
            params.scheduler_config_id.as_deref(),
            params.status.as_deref(),
        )?;

        Ok(PaginatedResponse {
            items: response.items,
            has_more: response.has_more,
        })
    }
}

/// Type alias for the scheduled compute nodes iterator
pub type ScheduledComputeNodesIterator = PaginatedIterator<ScheduledComputeNodesModel>;

/// Create a lazy iterator for scheduled compute nodes that fetches pages on-demand.
///
/// # Arguments
/// * `config` - API configuration
/// * `workflow_id` - ID of the workflow to list scheduled compute nodes from
/// * `params` - ScheduledComputeNodeListParams containing filter and pagination parameters
///
/// # Returns
/// An iterator that yields `Result<ScheduledComputeNodesModel, Error>` items
pub fn iter_scheduled_compute_nodes(
    config: &apis::configuration::Configuration,
    workflow_id: i64,
    params: ScheduledComputeNodeListParams,
) -> ScheduledComputeNodesIterator {
    let mut params = params;
    params.workflow_id = workflow_id;
    PaginatedIterator::new(config.clone(), params, None)
}

/// Collect all scheduled compute nodes into a vector using lazy iteration internally.
///
/// # Arguments
/// * `config` - API configuration
/// * `workflow_id` - ID of the workflow to list scheduled compute nodes from
/// * `params` - ScheduledComputeNodeListParams containing filter and pagination parameters
///
/// # Returns
/// `Result<Vec<ScheduledComputeNodesModel>, Error>` containing all scheduled compute nodes or an error
pub fn paginate_scheduled_compute_nodes(
    config: &apis::configuration::Configuration,
    workflow_id: i64,
    params: ScheduledComputeNodeListParams,
) -> Result<
    Vec<ScheduledComputeNodesModel>,
    apis::Error<apis::default_api::ListScheduledComputeNodesError>,
> {
    iter_scheduled_compute_nodes(config, workflow_id, params).collect()
}