oci-rust-sdk 0.4.4

Unofficial Oracle OCI SDK for 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
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

use serde::{Deserialize, Serialize};

#[allow(unused_imports)]
use super::*;
/// Defines an operation that is performed by a scheduled job.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ScheduledJobOperation {
    /// The type of operation this scheduled job performs.
    pub operation_type: OperationTypes,

    /// The names of the target packages. This parameter only applies when the scheduled job is for installing, updating, or removing packages.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub package_names: Option<Vec<String>>,

    /// Unique identifier for the Windows update. This parameter only applies if the scheduled job is for installing Windows updates. Note that this is not an OCID, but is a unique identifier assigned by Microsoft. For example: '6981d463-cd91-4a26-b7c4-ea4ded9183ed'.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub windows_update_names: Option<Vec<String>>,

    #[serde(skip_serializing_if = "Option::is_none")]
    pub manage_module_streams_details: Option<ManageModuleStreamsInScheduledJobDetails>,

    #[serde(skip_serializing_if = "Option::is_none")]
    pub switch_module_streams_details: Option<ModuleStreamDetails>,

    /// The software source [OCIDs](https://docs.oracle.com/iaas/Content/General/Concepts/identifiers.htm). This parameter only applies when the scheduled job is for attaching or detaching software sources.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub software_source_ids: Option<Vec<String>>,

    /// The number of minutes the service waits for the reboot to complete. If the instance doesn't reboot within the timeout, the service marks the reboot job as failed. Note: Numbers greater than Number.MAX_SAFE_INTEGER will result in rounding issues.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub reboot_timeout_in_mins: Option<i64>,
}

/// Required fields for ScheduledJobOperation
pub struct ScheduledJobOperationRequired {
    /// The type of operation this scheduled job performs.
    pub operation_type: OperationTypes,
}

impl ScheduledJobOperation {
    /// Create a new ScheduledJobOperation with required fields
    pub fn new(required: ScheduledJobOperationRequired) -> Self {
        Self {
            operation_type: required.operation_type,

            package_names: None,

            windows_update_names: None,

            manage_module_streams_details: None,

            switch_module_streams_details: None,

            software_source_ids: None,

            reboot_timeout_in_mins: None,
        }
    }

    /// Set operation_type
    pub fn set_operation_type(mut self, value: OperationTypes) -> Self {
        self.operation_type = value;
        self
    }

    /// Set package_names
    pub fn set_package_names(mut self, value: Option<Vec<String>>) -> Self {
        self.package_names = value;
        self
    }

    /// Set windows_update_names
    pub fn set_windows_update_names(mut self, value: Option<Vec<String>>) -> Self {
        self.windows_update_names = value;
        self
    }

    /// Set manage_module_streams_details
    pub fn set_manage_module_streams_details(
        mut self,
        value: Option<ManageModuleStreamsInScheduledJobDetails>,
    ) -> Self {
        self.manage_module_streams_details = value;
        self
    }

    /// Set switch_module_streams_details
    pub fn set_switch_module_streams_details(mut self, value: Option<ModuleStreamDetails>) -> Self {
        self.switch_module_streams_details = value;
        self
    }

    /// Set software_source_ids
    pub fn set_software_source_ids(mut self, value: Option<Vec<String>>) -> Self {
        self.software_source_ids = value;
        self
    }

    /// Set reboot_timeout_in_mins
    pub fn set_reboot_timeout_in_mins(mut self, value: Option<i64>) -> Self {
        self.reboot_timeout_in_mins = value;
        self
    }

    /// Set package_names (unwraps Option)
    pub fn with_package_names(mut self, value: Vec<String>) -> Self {
        self.package_names = Some(value);
        self
    }

    /// Set windows_update_names (unwraps Option)
    pub fn with_windows_update_names(mut self, value: Vec<String>) -> Self {
        self.windows_update_names = Some(value);
        self
    }

    /// Set manage_module_streams_details (unwraps Option)
    pub fn with_manage_module_streams_details(
        mut self,
        value: ManageModuleStreamsInScheduledJobDetails,
    ) -> Self {
        self.manage_module_streams_details = Some(value);
        self
    }

    /// Set switch_module_streams_details (unwraps Option)
    pub fn with_switch_module_streams_details(mut self, value: ModuleStreamDetails) -> Self {
        self.switch_module_streams_details = Some(value);
        self
    }

    /// Set software_source_ids (unwraps Option)
    pub fn with_software_source_ids(mut self, value: Vec<String>) -> Self {
        self.software_source_ids = Some(value);
        self
    }

    /// Set reboot_timeout_in_mins (unwraps Option)
    pub fn with_reboot_timeout_in_mins(mut self, value: i64) -> Self {
        self.reboot_timeout_in_mins = Some(value);
        self
    }
}