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
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
use std::sync::Arc;
use crate::core::client::{VimClient, Result};
/// Deprecated as of vSphere 9.0 APIs with no replacement.
///
/// Managed object responsible for reading and configuring
/// Non-Volatile DIMMs.
#[derive(Clone)]
pub struct HostNvdimmSystem {
client: Arc<dyn VimClient>,
mo_id: String,
}
impl HostNvdimmSystem {
pub fn new(client: Arc<dyn VimClient>, mo_id: &str) -> Self {
Self {
client,
mo_id: mo_id.to_string(),
}
}
/// Deprecated as of vSphere 6.7u1, use createPMemNamespace
/// Create nvd namespace from information passed in NamespaceCreationSpec.
///
/// A new block or persistent namespace can be created on the NVDIMM(s)
/// when the system is in maintenance mode.
///
/// If all the parameters passed
/// are valid and system is in maintenance mode, then a DSM (Device
/// Specific Method) call is made to create the namespace. DSM calls are
/// blockable and slow operations and hence the use of task.
///
/// If a new namespace is created, its UUID is returned.
///
/// ***Required privileges:*** Host.Config.Nvdimm
///
/// ## Parameters:
///
/// ### create_spec
/// Parameters to create the required namespace.
///
/// ## Returns:
///
/// This method returns a *Task* object which is used to
/// monitor this operation. The task result
/// (*Task.info*.*TaskInfo.result*) contains a
/// *NvdimmGuid* object that has the UUID of the
/// newly created namespace.
///
/// Refers instance of *Task*.
///
/// ## Errors:
///
/// ***InvalidArgument***: if an argument to create namespace is invalid.
///
/// ***NotSupported***: if no NVDIMMs are found, namespace type is
/// not supported or if operation does not have
/// DSM method.
///
/// ***InvalidHostState***: if operation is not allowed as system is not in
/// maintenance mode.
///
/// ***AlreadyExists***: if the namespace of type already exists.
///
/// ***SystemError***: for other system errors along with localized
/// reason for failure.
///
/// ***HostConfigFault***: for any other failure.
pub async fn create_nvdimm_namespace_task(&self, create_spec: &crate::types::structs::NvdimmNamespaceCreateSpec) -> Result<crate::types::structs::ManagedObjectReference> {
let input = CreateNvdimmNamespaceRequestType {create_spec, };
let bytes = self.client.invoke("", "HostNvdimmSystem", &self.mo_id, "CreateNvdimmNamespace_Task", Some(&input)).await?;
let result: crate::types::structs::ManagedObjectReference = crate::core::client::unmarshal(self.client.transport(), &bytes)?;
Ok(result)
}
/// Create persistent memory mode nvd namespace from information passed
/// in PMemNamespaceCreationSpec.
///
/// A new persistent namespace can be created on the NVDIMM(s)
/// when the system is in maintenance mode. If all the parameters passed
/// are valid and system is in maintenance mode, then a DSM (Device
/// Specific Method) call is made to create the namespace. DSM calls are
/// blockable and slow operations and hence the use of task.
///
/// If a new namespace is created, its UUID is returned.
///
/// ***Required privileges:*** Host.Config.Nvdimm
///
/// ## Parameters:
///
/// ### create_spec
/// Parameters to create the required namespace.
///
/// ## Returns:
///
/// This method returns a *Task* object which is used to
/// monitor this operation. The task result
/// (*Task.info*.*TaskInfo.result*) contains a
/// *NvdimmGuid* object that has the UUID of the
/// newly created namespace.
///
/// Refers instance of *Task*.
///
/// ## Errors:
///
/// ***InvalidArgument***: if an argument to create namespace is invalid.
///
/// ***NotSupported***: if no NVDIMMs are found or if operation does
/// not have the supporting DSM method.
///
/// ***InvalidHostState***: if operation is not allowed as system is not in
/// maintenance mode.
///
/// ***AlreadyExists***: if the namespace of type already exists.
///
/// ***SystemError***: for other system errors along with localized
/// reason for failure.
///
/// ***HostConfigFault***: for any other failure.
pub async fn create_nvdimm_p_mem_namespace_task(&self, create_spec: &crate::types::structs::NvdimmPMemNamespaceCreateSpec) -> Result<crate::types::structs::ManagedObjectReference> {
let input = CreateNvdimmPMemNamespaceRequestType {create_spec, };
let bytes = self.client.invoke("", "HostNvdimmSystem", &self.mo_id, "CreateNvdimmPMemNamespace_Task", Some(&input)).await?;
let result: crate::types::structs::ManagedObjectReference = crate::core::client::unmarshal(self.client.transport(), &bytes)?;
Ok(result)
}
/// Delete all block mode namespaces in the system.
///
/// Existing block namespace(s) can be deleted from all NVDIMMs, if the
/// system is in maintenance mode. If paramters passed are valid and
/// the system is in maintenance mode, then DSM calls are made to
/// delete these namespaces. DSM calls are blockable, slow operations
/// and hence the use of task.
///
/// If a particular block namespace is to be deleted, use
/// *HostNvdimmSystem.DeleteNvdimmNamespace_Task* by passing it the UUID
/// of the block namespace.
///
/// ***Required privileges:*** Host.Config.Nvdimm
///
/// ## Returns:
///
/// This method returns a *Task* object which is used to
/// monitor this operation.
///
/// Refers instance of *Task*.
///
/// ## Errors:
///
/// ***InvalidArgument***: if UUID of namespace to be created is invalid.
///
/// ***NotFound***: if the namespace to be deleted is not found.
///
/// ***NotSupported***: if no NVDIMMs are found and if operation does
/// not have DSM method.
///
/// ***InvalidHostState***: if operation is not allowed as system is not
/// in maintenance mode.
///
/// ***SystemError***: for any other system error along with localized
/// reason for failure.
///
/// ***HostConfigFault***: for any other failure.
pub async fn delete_nvdimm_block_namespaces_task(&self) -> Result<crate::types::structs::ManagedObjectReference> {
let bytes = self.client.invoke("", "HostNvdimmSystem", &self.mo_id, "DeleteNvdimmBlockNamespaces_Task", None).await?;
let result: crate::types::structs::ManagedObjectReference = crate::core::client::unmarshal(self.client.transport(), &bytes)?;
Ok(result)
}
/// Delete nvd namespace whose uuid matches passed parameter.
///
/// An existing namespace of type block or persistent mode can be deleted
/// from NVDIMM(s), if the system is in maintenance mode. If paramters
/// passed are valid and the system is in maintenance mode, then a DSM call
/// is made to delete this namespace. DSM calls are blockable, slow
/// operations and hence the use of task.
///
/// ***Required privileges:*** Host.Config.Nvdimm
///
/// ## Parameters:
///
/// ### delete_spec
/// Details of namespace to be deleted.
///
/// ## Returns:
///
/// This method returns a *Task* object which is used to
/// monitor this operation.
///
/// Refers instance of *Task*.
///
/// ## Errors:
///
/// ***InvalidArgument***: if UUID of namespace to be created is invalid.
///
/// ***NotFound***: if the namespace to be deleted is not found.
///
/// ***NotSupported***: if no NVDIMMs are found or if operation does
/// not have DSM method.
///
/// ***InvalidHostState***: if operation is not allowed as system is not in
/// maintenance mode.
///
/// ***SystemError***: for any other system error along with
/// localized reason for failure.
///
/// ***HostConfigFault***: for any other failure.
pub async fn delete_nvdimm_namespace_task(&self, delete_spec: &crate::types::structs::NvdimmNamespaceDeleteSpec) -> Result<crate::types::structs::ManagedObjectReference> {
let input = DeleteNvdimmNamespaceRequestType {delete_spec, };
let bytes = self.client.invoke("", "HostNvdimmSystem", &self.mo_id, "DeleteNvdimmNamespace_Task", Some(&input)).await?;
let result: crate::types::structs::ManagedObjectReference = crate::core::client::unmarshal(self.client.transport(), &bytes)?;
Ok(result)
}
/// Host NVDIMM information.
///
/// \- Summary of all dimms on the host.
/// \- Array of all DIMMs on the host.
/// \- Array of DIMM information and health for all dimms on the host.
/// \- Array of interleave set for all sets on the host.
/// \- Array of interleave set information for all sets on the host.
/// \- Array of namespace IDs for all dimms on the host.
/// \- Array of namespace details of all dimms on the host.
///
/// ***Required privileges:*** Host.Config.Nvdimm
///
/// ## Returns:
///
/// Return set of all NVDIMM related information.
pub async fn nvdimm_system_info(&self) -> Result<crate::types::structs::NvdimmSystemInfo> {
let pv_opt = self.client.fetch_property_raw("", "HostNvdimmSystem", &self.mo_id, "nvdimmSystemInfo").await?;
let pv = pv_opt.ok_or_else(|| crate::core::client::VimError::ParseError("property nvdimmSystemInfo was empty".to_string()))?;
let result: crate::types::structs::NvdimmSystemInfo = crate::core::client::extract_property(pv)?;
Ok(result)
}
}
struct CreateNvdimmNamespaceRequestType<'a> {
create_spec: &'a crate::types::structs::NvdimmNamespaceCreateSpec,
}
impl<'a> miniserde::Serialize for CreateNvdimmNamespaceRequestType<'a> {
fn begin(&self) -> miniserde::ser::Fragment<'_> {
miniserde::ser::Fragment::Map(Box::new(CreateNvdimmNamespaceRequestTypeSer { data: self, seq: 0 }))
}
}
struct CreateNvdimmNamespaceRequestTypeSer<'b, 'a> {
data: &'b CreateNvdimmNamespaceRequestType<'a>,
seq: usize,
}
impl<'b, 'a> miniserde::ser::Map for CreateNvdimmNamespaceRequestTypeSer<'b, 'a> {
fn next(&mut self) -> Option<(std::borrow::Cow<'_, str>, &dyn miniserde::Serialize)> {
let seq = self.seq;
self.seq += 1;
match seq {
0 => return Some((std::borrow::Cow::Borrowed("_typeName"), &"CreateNvdimmNamespaceRequestType")),
1 => return Some((std::borrow::Cow::Borrowed("createSpec"), &self.data.create_spec as &dyn miniserde::Serialize)),
_ => return None,
}
}
}
struct CreateNvdimmPMemNamespaceRequestType<'a> {
create_spec: &'a crate::types::structs::NvdimmPMemNamespaceCreateSpec,
}
impl<'a> miniserde::Serialize for CreateNvdimmPMemNamespaceRequestType<'a> {
fn begin(&self) -> miniserde::ser::Fragment<'_> {
miniserde::ser::Fragment::Map(Box::new(CreateNvdimmPMemNamespaceRequestTypeSer { data: self, seq: 0 }))
}
}
struct CreateNvdimmPMemNamespaceRequestTypeSer<'b, 'a> {
data: &'b CreateNvdimmPMemNamespaceRequestType<'a>,
seq: usize,
}
impl<'b, 'a> miniserde::ser::Map for CreateNvdimmPMemNamespaceRequestTypeSer<'b, 'a> {
fn next(&mut self) -> Option<(std::borrow::Cow<'_, str>, &dyn miniserde::Serialize)> {
let seq = self.seq;
self.seq += 1;
match seq {
0 => return Some((std::borrow::Cow::Borrowed("_typeName"), &"CreateNvdimmPMemNamespaceRequestType")),
1 => return Some((std::borrow::Cow::Borrowed("createSpec"), &self.data.create_spec as &dyn miniserde::Serialize)),
_ => return None,
}
}
}
struct DeleteNvdimmNamespaceRequestType<'a> {
delete_spec: &'a crate::types::structs::NvdimmNamespaceDeleteSpec,
}
impl<'a> miniserde::Serialize for DeleteNvdimmNamespaceRequestType<'a> {
fn begin(&self) -> miniserde::ser::Fragment<'_> {
miniserde::ser::Fragment::Map(Box::new(DeleteNvdimmNamespaceRequestTypeSer { data: self, seq: 0 }))
}
}
struct DeleteNvdimmNamespaceRequestTypeSer<'b, 'a> {
data: &'b DeleteNvdimmNamespaceRequestType<'a>,
seq: usize,
}
impl<'b, 'a> miniserde::ser::Map for DeleteNvdimmNamespaceRequestTypeSer<'b, 'a> {
fn next(&mut self) -> Option<(std::borrow::Cow<'_, str>, &dyn miniserde::Serialize)> {
let seq = self.seq;
self.seq += 1;
match seq {
0 => return Some((std::borrow::Cow::Borrowed("_typeName"), &"DeleteNvdimmNamespaceRequestType")),
1 => return Some((std::borrow::Cow::Borrowed("deleteSpec"), &self.data.delete_spec as &dyn miniserde::Serialize)),
_ => return None,
}
}
}