use crate::CompositeId;
use crate::ToCompositeId;
use crate::{EndpointName, Fqdn, Label};
use std::{collections::BTreeSet, fmt, ops::Deref, path::PathBuf};
#[cfg(feature = "postgres-interop")]
use bytes::BytesMut;
#[cfg(feature = "postgres-interop")]
use postgres_types::{to_sql_checked, FromSql, IsNull, ToSql, Type};
#[cfg(feature = "postgres-interop")]
use std::io;
#[cfg(feature = "postgres-interop")]
use tokio_postgres::Row;
pub trait Id {
fn id(&self) -> u32;
}
pub trait NotDeleted {
fn not_deleted(&self) -> bool;
fn deleted(&self) -> bool {
!self.not_deleted()
}
}
fn not_deleted(x: Option<bool>) -> bool {
x.filter(|&x| x).is_some()
}
#[derive(serde::Deserialize, Debug, PartialEq, Eq)]
#[serde(transparent)]
pub struct TableName<'a>(pub &'a str);
impl fmt::Display for TableName<'_> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "{}", self.0)
}
}
pub trait Name {
fn table_name() -> TableName<'static>;
}
#[derive(serde::Serialize, serde::Deserialize, PartialEq, Clone, Debug)]
pub struct ContentTypeRecord {
pub id: u32,
pub app_label: String,
pub model: String,
}
impl Id for ContentTypeRecord {
fn id(&self) -> u32 {
self.id
}
}
pub const CONTENT_TYPE_TABLE_NAME: TableName = TableName("django_content_type");
impl Name for ContentTypeRecord {
fn table_name() -> TableName<'static> {
CONTENT_TYPE_TABLE_NAME
}
}
#[cfg(feature = "postgres-interop")]
impl From<Row> for ContentTypeRecord {
fn from(row: Row) -> Self {
ContentTypeRecord {
id: row.get::<_, i32>("id") as u32,
app_label: row.get("app_label"),
model: row.get("model"),
}
}
}
#[derive(serde::Deserialize, Debug)]
pub struct FsRecord {
id: u32,
state_modified_at: String,
state: String,
immutable_state: bool,
name: String,
mgs_id: u32,
mdt_next_index: u32,
ost_next_index: u32,
not_deleted: Option<bool>,
content_type_id: Option<u32>,
}
impl Id for FsRecord {
fn id(&self) -> u32 {
self.id
}
}
impl NotDeleted for FsRecord {
fn not_deleted(&self) -> bool {
not_deleted(self.not_deleted)
}
}
pub const MANAGED_FILESYSTEM_TABLE_NAME: TableName = TableName("chroma_core_managedfilesystem");
impl Name for FsRecord {
fn table_name() -> TableName<'static> {
MANAGED_FILESYSTEM_TABLE_NAME
}
}
#[derive(serde::Serialize, serde::Deserialize, PartialEq, Clone, Debug)]
pub struct VolumeRecord {
pub id: u32,
pub storage_resource_id: Option<u32>,
pub size: Option<u64>,
pub label: String,
pub filesystem_type: Option<String>,
pub not_deleted: Option<bool>,
pub usable_for_lustre: bool,
}
impl Id for VolumeRecord {
fn id(&self) -> u32 {
self.id
}
}
impl NotDeleted for VolumeRecord {
fn not_deleted(&self) -> bool {
not_deleted(self.not_deleted)
}
}
pub const VOLUME_TABLE_NAME: TableName = TableName("chroma_core_volume");
impl Name for VolumeRecord {
fn table_name() -> TableName<'static> {
VOLUME_TABLE_NAME
}
}
#[cfg(feature = "postgres-interop")]
impl From<Row> for VolumeRecord {
fn from(row: Row) -> Self {
VolumeRecord {
id: row.get::<_, i32>("id") as u32,
size: row.get::<_, Option<i64>>("size").map(|x| x as u64),
label: row.get("label"),
filesystem_type: row.get("filesystem_type"),
usable_for_lustre: row.get("usable_for_lustre"),
not_deleted: row.get("not_deleted"),
storage_resource_id: row
.get::<_, Option<i32>>("storage_resource_id")
.map(|x| x as u32),
}
}
}
#[derive(serde::Serialize, serde::Deserialize, PartialEq, Clone, Debug)]
pub struct VolumeNodeRecord {
pub id: u32,
pub volume_id: u32,
pub host_id: u32,
pub path: String,
pub storage_resource_id: Option<u32>,
pub primary: bool,
#[serde(rename = "use")]
pub _use: bool,
pub not_deleted: Option<bool>,
}
impl Id for VolumeNodeRecord {
fn id(&self) -> u32 {
self.id
}
}
impl Id for &VolumeNodeRecord {
fn id(&self) -> u32 {
self.id
}
}
impl NotDeleted for VolumeNodeRecord {
fn not_deleted(&self) -> bool {
not_deleted(self.not_deleted)
}
}
impl Label for VolumeNodeRecord {
fn label(&self) -> &str {
&self.path
}
}
impl Label for &VolumeNodeRecord {
fn label(&self) -> &str {
&self.path
}
}
pub const VOLUME_NODE_TABLE_NAME: TableName = TableName("chroma_core_volumenode");
impl Name for VolumeNodeRecord {
fn table_name() -> TableName<'static> {
VOLUME_NODE_TABLE_NAME
}
}
#[cfg(feature = "postgres-interop")]
impl From<Row> for VolumeNodeRecord {
fn from(row: Row) -> Self {
VolumeNodeRecord {
id: row.get::<_, i32>("id") as u32,
volume_id: row.get::<_, i32>("volume_id") as u32,
host_id: row.get::<_, i32>("host_id") as u32,
path: row.get("path"),
storage_resource_id: row
.get::<_, Option<i32>>("storage_resource_id")
.map(|x| x as u32),
primary: row.get("primary"),
_use: row.get("use"),
not_deleted: row.get("not_deleted"),
}
}
}
#[derive(serde::Serialize, serde::Deserialize, PartialEq, Clone, Debug)]
pub struct ManagedTargetMountRecord {
pub id: u32,
pub host_id: u32,
pub mount_point: Option<String>,
pub volume_node_id: u32,
pub primary: bool,
pub target_id: u32,
pub not_deleted: Option<bool>,
}
impl Id for ManagedTargetMountRecord {
fn id(&self) -> u32 {
self.id
}
}
impl NotDeleted for ManagedTargetMountRecord {
fn not_deleted(&self) -> bool {
not_deleted(self.not_deleted)
}
}
#[cfg(feature = "postgres-interop")]
impl From<Row> for ManagedTargetMountRecord {
fn from(row: Row) -> Self {
ManagedTargetMountRecord {
id: row.get::<_, i32>("id") as u32,
host_id: row.get::<_, i32>("host_id") as u32,
mount_point: row.get("mount_point"),
volume_node_id: row.get::<_, i32>("volume_node_id") as u32,
primary: row.get("primary"),
target_id: row.get::<_, i32>("target_id") as u32,
not_deleted: row.get("not_deleted"),
}
}
}
pub const MANAGED_TARGET_MOUNT_TABLE_NAME: TableName = TableName("chroma_core_managedtargetmount");
impl Name for ManagedTargetMountRecord {
fn table_name() -> TableName<'static> {
MANAGED_TARGET_MOUNT_TABLE_NAME
}
}
#[derive(serde::Deserialize, Debug)]
pub struct ManagedTargetRecord {
id: u32,
state_modified_at: String,
state: String,
immutable_state: bool,
name: Option<String>,
uuid: Option<String>,
ha_label: Option<String>,
volume_id: u32,
inode_size: Option<u32>,
bytes_per_inode: Option<u32>,
inode_count: Option<u64>,
reformat: bool,
active_mount_id: Option<u32>,
not_deleted: Option<bool>,
content_type_id: Option<u32>,
}
impl Id for ManagedTargetRecord {
fn id(&self) -> u32 {
self.id
}
}
impl NotDeleted for ManagedTargetRecord {
fn not_deleted(&self) -> bool {
not_deleted(self.not_deleted)
}
}
pub const MANAGED_TARGET_TABLE_NAME: TableName = TableName("chroma_core_managedtarget");
impl Name for ManagedTargetRecord {
fn table_name() -> TableName<'static> {
MANAGED_TARGET_TABLE_NAME
}
}
#[derive(serde::Serialize, serde::Deserialize, PartialEq, Clone, Debug)]
pub struct OstPoolRecord {
pub id: u32,
pub name: String,
pub filesystem_id: u32,
pub not_deleted: Option<bool>,
pub content_type_id: Option<u32>,
}
impl Id for OstPoolRecord {
fn id(&self) -> u32 {
self.id
}
}
impl Id for &OstPoolRecord {
fn id(&self) -> u32 {
self.id
}
}
impl NotDeleted for OstPoolRecord {
fn not_deleted(&self) -> bool {
not_deleted(self.not_deleted)
}
}
#[cfg(feature = "postgres-interop")]
impl From<Row> for OstPoolRecord {
fn from(row: Row) -> Self {
OstPoolRecord {
id: row.get::<_, i32>("id") as u32,
name: row.get("name"),
filesystem_id: row.get::<_, i32>("filesystem_id") as u32,
not_deleted: row.get("not_deleted"),
content_type_id: row
.get::<_, Option<i32>>("content_type_id")
.map(|x| x as u32),
}
}
}
pub const OSTPOOL_TABLE_NAME: TableName = TableName("chroma_core_ostpool");
impl Name for OstPoolRecord {
fn table_name() -> TableName<'static> {
OSTPOOL_TABLE_NAME
}
}
impl Label for OstPoolRecord {
fn label(&self) -> &str {
&self.name
}
}
impl Label for &OstPoolRecord {
fn label(&self) -> &str {
&self.name
}
}
#[derive(serde::Serialize, serde::Deserialize, PartialEq, Clone, Debug)]
pub struct OstPoolOstsRecord {
pub id: u32,
pub ostpool_id: u32,
pub managedost_id: u32,
}
impl Id for OstPoolOstsRecord {
fn id(&self) -> u32 {
self.id
}
}
#[cfg(feature = "postgres-interop")]
impl From<Row> for OstPoolOstsRecord {
fn from(row: Row) -> Self {
OstPoolOstsRecord {
id: row.get::<_, i32>("id") as u32,
ostpool_id: row.get::<_, i32>("ostpool_id") as u32,
managedost_id: row.get::<_, i32>("managedost_id") as u32,
}
}
}
pub const OSTPOOL_OSTS_TABLE_NAME: TableName = TableName("chroma_core_ostpool_osts");
impl Name for OstPoolOstsRecord {
fn table_name() -> TableName<'static> {
OSTPOOL_OSTS_TABLE_NAME
}
}
#[derive(serde::Deserialize, Debug)]
pub struct ManagedOstRecord {
managedtarget_ptr_id: u32,
index: u32,
filesystem_id: u32,
}
impl Id for ManagedOstRecord {
fn id(&self) -> u32 {
self.managedtarget_ptr_id
}
}
impl NotDeleted for ManagedOstRecord {
fn not_deleted(&self) -> bool {
true
}
}
pub const MANAGED_OST_TABLE_NAME: TableName = TableName("chroma_core_managedost");
impl Name for ManagedOstRecord {
fn table_name() -> TableName<'static> {
MANAGED_OST_TABLE_NAME
}
}
#[derive(serde::Deserialize, Debug)]
pub struct ManagedMdtRecord {
managedtarget_ptr_id: u32,
index: u32,
filesystem_id: u32,
}
impl Id for ManagedMdtRecord {
fn id(&self) -> u32 {
self.managedtarget_ptr_id
}
}
impl NotDeleted for ManagedMdtRecord {
fn not_deleted(&self) -> bool {
true
}
}
pub const MANAGED_MDT_TABLE_NAME: TableName = TableName("chroma_core_managedmdt");
impl Name for ManagedMdtRecord {
fn table_name() -> TableName<'static> {
MANAGED_MDT_TABLE_NAME
}
}
#[derive(serde::Deserialize, Debug)]
pub struct ManagedHostRecord {
id: u32,
state_modified_at: String,
state: String,
immutable_state: bool,
not_deleted: Option<bool>,
content_type_id: Option<u32>,
address: String,
fqdn: String,
nodename: String,
boot_time: Option<String>,
server_profile_id: Option<String>,
needs_update: bool,
install_method: String,
properties: String,
corosync_ring0: String,
}
impl Id for ManagedHostRecord {
fn id(&self) -> u32 {
self.id
}
}
impl NotDeleted for ManagedHostRecord {
fn not_deleted(&self) -> bool {
not_deleted(self.not_deleted)
}
}
pub const MANAGED_HOST_TABLE_NAME: TableName = TableName("chroma_core_managedhost");
impl Name for ManagedHostRecord {
fn table_name() -> TableName<'static> {
MANAGED_HOST_TABLE_NAME
}
}
#[derive(serde::Deserialize, Debug)]
pub struct AlertStateRecord {
id: u32,
alert_item_type_id: Option<u32>,
alert_item_id: Option<u32>,
alert_type: String,
begin: String,
end: Option<String>,
active: Option<bool>,
dismissed: bool,
severity: u32,
record_type: String,
variant: Option<String>,
lustre_pid: Option<u32>,
message: Option<String>,
}
impl AlertStateRecord {
pub fn is_active(&self) -> bool {
self.active.is_some()
}
}
impl Id for AlertStateRecord {
fn id(&self) -> u32 {
self.id
}
}
pub const ALERT_STATE_TABLE_NAME: TableName = TableName("chroma_core_alertstate");
impl Name for AlertStateRecord {
fn table_name() -> TableName<'static> {
ALERT_STATE_TABLE_NAME
}
}
#[derive(serde::Serialize, serde::Deserialize, PartialEq, Clone, Debug)]
pub struct StratagemConfiguration {
pub id: u32,
pub filesystem_id: u32,
pub interval: u64,
pub report_duration: Option<u64>,
pub purge_duration: Option<u64>,
pub immutable_state: bool,
pub not_deleted: Option<bool>,
pub state: String,
}
#[cfg(feature = "postgres-interop")]
impl From<Row> for StratagemConfiguration {
fn from(row: Row) -> Self {
StratagemConfiguration {
id: row.get::<_, i32>("id") as u32,
filesystem_id: row.get::<_, i32>("filesystem_id") as u32,
interval: row.get::<_, i64>("interval") as u64,
report_duration: row
.get::<_, Option<i64>>("report_duration")
.map(|x| x as u64),
purge_duration: row
.get::<_, Option<i64>>("purge_duration")
.map(|x| x as u64),
immutable_state: row.get("immutable_state"),
not_deleted: row.get("not_deleted"),
state: row.get("state"),
}
}
}
impl Id for StratagemConfiguration {
fn id(&self) -> u32 {
self.id
}
}
impl NotDeleted for StratagemConfiguration {
fn not_deleted(&self) -> bool {
not_deleted(self.not_deleted)
}
}
pub const STRATAGEM_CONFIGURATION_TABLE_NAME: TableName =
TableName("chroma_core_stratagemconfiguration");
impl Name for StratagemConfiguration {
fn table_name() -> TableName<'static> {
STRATAGEM_CONFIGURATION_TABLE_NAME
}
}
impl Label for StratagemConfiguration {
fn label(&self) -> &str {
"Stratagem Configuration"
}
}
impl EndpointName for StratagemConfiguration {
fn endpoint_name() -> &'static str {
"stratagem_configuration"
}
}
#[derive(serde::Serialize, serde::Deserialize, PartialEq, Clone, Debug)]
pub struct LnetConfigurationRecord {
pub id: u32,
pub state: String,
pub host_id: u32,
pub immutable_state: bool,
pub not_deleted: Option<bool>,
pub content_type_id: Option<u32>,
}
#[cfg(feature = "postgres-interop")]
impl From<Row> for LnetConfigurationRecord {
fn from(row: Row) -> Self {
LnetConfigurationRecord {
id: row.get::<_, i32>("id") as u32,
state: row.get("state"),
host_id: row.get::<_, i32>("host_id") as u32,
immutable_state: row.get("immutable_state"),
not_deleted: row.get("not_deleted"),
content_type_id: row
.get::<_, Option<i32>>("content_type_id")
.map(|x| x as u32),
}
}
}
impl Id for LnetConfigurationRecord {
fn id(&self) -> u32 {
self.id
}
}
impl NotDeleted for LnetConfigurationRecord {
fn not_deleted(&self) -> bool {
not_deleted(self.not_deleted)
}
}
impl EndpointName for LnetConfigurationRecord {
fn endpoint_name() -> &'static str {
"lnet_configuration"
}
}
impl Label for LnetConfigurationRecord {
fn label(&self) -> &str {
"lnet configuration"
}
}
impl ToCompositeId for LnetConfigurationRecord {
fn composite_id(&self) -> CompositeId {
CompositeId(self.content_type_id.unwrap(), self.id)
}
}
impl ToCompositeId for &LnetConfigurationRecord {
fn composite_id(&self) -> CompositeId {
CompositeId(self.content_type_id.unwrap(), self.id)
}
}
pub const LNET_CONFIGURATION_TABLE_NAME: TableName = TableName("chroma_core_lnetconfiguration");
impl Name for LnetConfigurationRecord {
fn table_name() -> TableName<'static> {
LNET_CONFIGURATION_TABLE_NAME
}
}
#[derive(
Debug, serde::Serialize, serde::Deserialize, Eq, PartialEq, Ord, PartialOrd, Clone, Hash,
)]
pub struct DeviceId(String);
#[cfg(feature = "postgres-interop")]
impl ToSql for DeviceId {
fn to_sql(
&self,
ty: &Type,
w: &mut BytesMut,
) -> Result<IsNull, Box<dyn std::error::Error + Sync + Send>> {
<&str as ToSql>::to_sql(&&*self.0, ty, w)
}
fn accepts(ty: &Type) -> bool {
<&str as ToSql>::accepts(ty)
}
to_sql_checked!();
}
#[cfg(feature = "postgres-interop")]
impl<'a> FromSql<'a> for DeviceId {
fn from_sql(
ty: &Type,
raw: &'a [u8],
) -> Result<DeviceId, Box<dyn std::error::Error + Sync + Send>> {
FromSql::from_sql(ty, raw).map(DeviceId)
}
fn accepts(ty: &Type) -> bool {
<String as FromSql>::accepts(ty)
}
}
impl Deref for DeviceId {
type Target = String;
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[derive(Debug, Default, PartialEq, Eq)]
pub struct DeviceIds(pub BTreeSet<DeviceId>);
impl Deref for DeviceIds {
type Target = BTreeSet<DeviceId>;
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[cfg(feature = "postgres-interop")]
impl ToSql for DeviceIds {
fn to_sql(
&self,
ty: &Type,
w: &mut BytesMut,
) -> Result<IsNull, Box<dyn std::error::Error + Sync + Send>> {
let xs = self.0.iter().collect::<Vec<_>>();
<&[&DeviceId] as ToSql>::to_sql(&&*xs, ty, w)
}
fn accepts(ty: &Type) -> bool {
<&[&DeviceId] as ToSql>::accepts(ty)
}
to_sql_checked!();
}
#[cfg(feature = "postgres-interop")]
impl<'a> FromSql<'a> for DeviceIds {
fn from_sql(
ty: &Type,
raw: &'a [u8],
) -> Result<DeviceIds, Box<dyn std::error::Error + Sync + Send>> {
<Vec<DeviceId> as FromSql>::from_sql(ty, raw).map(|xs| DeviceIds(xs.into_iter().collect()))
}
fn accepts(ty: &Type) -> bool {
<Vec<DeviceId> as FromSql>::accepts(ty)
}
}
#[derive(Debug, PartialEq, Eq)]
pub struct Size(pub u64);
#[cfg(feature = "postgres-interop")]
impl ToSql for Size {
fn to_sql(
&self,
ty: &Type,
w: &mut BytesMut,
) -> Result<IsNull, Box<dyn std::error::Error + Sync + Send>> {
<&str as ToSql>::to_sql(&&*self.0.to_string(), ty, w)
}
fn accepts(ty: &Type) -> bool {
<&str as ToSql>::accepts(ty)
}
to_sql_checked!();
}
#[cfg(feature = "postgres-interop")]
impl<'a> FromSql<'a> for Size {
fn from_sql(
ty: &Type,
raw: &'a [u8],
) -> Result<Size, Box<dyn std::error::Error + Sync + Send>> {
<String as FromSql>::from_sql(ty, raw).and_then(|x| {
x.parse::<u64>()
.map(Size)
.map_err(|e| -> Box<dyn std::error::Error + Sync + Send> { Box::new(e) })
})
}
fn accepts(ty: &Type) -> bool {
<String as FromSql>::accepts(ty)
}
}
#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash, serde::Serialize, serde::Deserialize)]
pub enum DeviceType {
ScsiDevice,
Partition,
MdRaid,
Mpath,
VolumeGroup,
LogicalVolume,
Zpool,
Dataset,
}
impl std::fmt::Display for DeviceType {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
match self {
Self::ScsiDevice => write!(f, "scsi"),
Self::Partition => write!(f, "partition"),
Self::MdRaid => write!(f, "mdraid"),
Self::Mpath => write!(f, "mpath"),
Self::VolumeGroup => write!(f, "vg"),
Self::LogicalVolume => write!(f, "lv"),
Self::Zpool => write!(f, "zpool"),
Self::Dataset => write!(f, "dataset"),
}
}
}
#[cfg(feature = "postgres-interop")]
impl ToSql for DeviceType {
fn to_sql(
&self,
ty: &Type,
w: &mut BytesMut,
) -> Result<IsNull, Box<dyn std::error::Error + Sync + Send>> {
<String as ToSql>::to_sql(&format!("{}", self), ty, w)
}
fn accepts(ty: &Type) -> bool {
<String as ToSql>::accepts(ty)
}
to_sql_checked!();
}
#[cfg(feature = "postgres-interop")]
impl<'a> FromSql<'a> for DeviceType {
fn from_sql(
ty: &Type,
raw: &'a [u8],
) -> Result<DeviceType, Box<dyn std::error::Error + Sync + Send>> {
FromSql::from_sql(ty, raw).and_then(|x| match x {
"scsi" => Ok(DeviceType::ScsiDevice),
"partition" => Ok(DeviceType::Partition),
"mdraid" => Ok(DeviceType::MdRaid),
"mpath" => Ok(DeviceType::Mpath),
"vg" => Ok(DeviceType::VolumeGroup),
"lv" => Ok(DeviceType::LogicalVolume),
"zpool" => Ok(DeviceType::Zpool),
"dataset" => Ok(DeviceType::Dataset),
_ => {
let e: Box<dyn std::error::Error + Sync + Send> = Box::new(io::Error::new(
io::ErrorKind::InvalidInput,
"Unknown DeviceType variant",
));
Err(e)
}
})
}
fn accepts(ty: &Type) -> bool {
<String as FromSql>::accepts(ty)
}
}
#[derive(Debug, PartialEq, Eq)]
pub struct Device {
pub id: DeviceId,
pub size: Size,
pub usable_for_lustre: bool,
pub device_type: DeviceType,
pub parents: DeviceIds,
pub children: DeviceIds,
}
pub const DEVICE_TABLE_NAME: TableName = TableName("chroma_core_device");
impl Name for Device {
fn table_name() -> TableName<'static> {
DEVICE_TABLE_NAME
}
}
#[cfg(feature = "postgres-interop")]
impl From<Row> for Device {
fn from(row: Row) -> Self {
Device {
id: row.get("id"),
size: row.get("size"),
usable_for_lustre: row.get("usable_for_lustre"),
device_type: row.get("device_type"),
parents: row.get("parents"),
children: row.get("children"),
}
}
}
#[derive(Debug, PartialEq, Eq)]
pub struct Paths(pub BTreeSet<PathBuf>);
impl Deref for Paths {
type Target = BTreeSet<PathBuf>;
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[cfg(feature = "postgres-interop")]
impl ToSql for Paths {
fn to_sql(
&self,
ty: &Type,
w: &mut BytesMut,
) -> Result<IsNull, Box<dyn std::error::Error + Sync + Send>> {
let xs = self.iter().map(|x| x.to_string_lossy()).collect::<Vec<_>>();
<&[std::borrow::Cow<'_, str>] as ToSql>::to_sql(&&*xs, ty, w)
}
fn accepts(ty: &Type) -> bool {
<&[std::borrow::Cow<'_, str>] as ToSql>::accepts(ty)
}
to_sql_checked!();
}
#[cfg(feature = "postgres-interop")]
impl<'a> FromSql<'a> for Paths {
fn from_sql(
ty: &Type,
raw: &'a [u8],
) -> Result<Paths, Box<dyn std::error::Error + Sync + Send>> {
<Vec<String> as FromSql>::from_sql(ty, raw)
.map(|xs| Paths(xs.into_iter().map(PathBuf::from).collect()))
}
fn accepts(ty: &Type) -> bool {
<Vec<String> as FromSql>::accepts(ty)
}
}
#[derive(Debug, PartialEq, Eq)]
pub struct MountPath(pub Option<PathBuf>);
#[cfg(feature = "postgres-interop")]
impl ToSql for MountPath {
fn to_sql(
&self,
ty: &Type,
w: &mut BytesMut,
) -> Result<IsNull, Box<dyn std::error::Error + Sync + Send>> {
<&Option<String> as ToSql>::to_sql(
&&self.0.clone().map(|x| x.to_string_lossy().into_owned()),
ty,
w,
)
}
fn accepts(ty: &Type) -> bool {
<&Option<String> as ToSql>::accepts(ty)
}
to_sql_checked!();
}
#[cfg(feature = "postgres-interop")]
impl Deref for MountPath {
type Target = Option<PathBuf>;
fn deref(&self) -> &Self::Target {
&self.0
}
}
#[derive(Debug, PartialEq, Eq)]
pub struct DeviceHost {
pub device_id: DeviceId,
pub fqdn: Fqdn,
pub local: bool,
pub paths: Paths,
pub mount_path: MountPath,
pub fs_type: Option<String>,
pub fs_label: Option<String>,
pub fs_uuid: Option<String>,
}
pub const DEVICE_HOST_TABLE_NAME: TableName = TableName("chroma_core_devicehost");
impl Name for DeviceHost {
fn table_name() -> TableName<'static> {
DEVICE_HOST_TABLE_NAME
}
}
#[cfg(feature = "postgres-interop")]
impl From<Row> for DeviceHost {
fn from(row: Row) -> Self {
DeviceHost {
device_id: row.get("device_id"),
fqdn: Fqdn(row.get::<_, String>("fqdn")),
local: row.get("local"),
paths: row.get("paths"),
mount_path: MountPath(
row.get::<_, Option<String>>("mount_path")
.map(PathBuf::from),
),
fs_type: row.get::<_, Option<String>>("fs_type"),
fs_label: row.get::<_, Option<String>>("fs_label"),
fs_uuid: row.get::<_, Option<String>>("fs_uuid"),
}
}
}
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
pub struct AuthUserRecord {
pub id: u32,
pub is_superuser: bool,
pub username: String,
pub first_name: String,
pub last_name: String,
pub email: String,
pub is_staff: bool,
pub is_active: bool,
}
pub const AUTH_USER_TABLE_NAME: TableName = TableName("auth_user");
impl Name for AuthUserRecord {
fn table_name() -> TableName<'static> {
AUTH_USER_TABLE_NAME
}
}
impl Id for AuthUserRecord {
fn id(&self) -> u32 {
self.id
}
}
#[cfg(feature = "postgres-interop")]
impl From<Row> for AuthUserRecord {
fn from(row: Row) -> Self {
Self {
id: row.get::<_, i32>("id") as u32,
is_superuser: row.get("is_superuser"),
username: row.get("username"),
first_name: row.get("first_name"),
last_name: row.get("last_name"),
email: row.get("email"),
is_staff: row.get("is_staff"),
is_active: row.get("is_active"),
}
}
}
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
pub struct AuthUserGroupRecord {
pub id: u32,
pub user_id: u32,
pub group_id: u32,
}
pub const AUTH_USER_GROUP_TABLE_NAME: TableName = TableName("auth_user_groups");
impl Name for AuthUserGroupRecord {
fn table_name() -> TableName<'static> {
AUTH_USER_GROUP_TABLE_NAME
}
}
impl Id for AuthUserGroupRecord {
fn id(&self) -> u32 {
self.id
}
}
#[cfg(feature = "postgres-interop")]
impl From<Row> for AuthUserGroupRecord {
fn from(row: Row) -> Self {
Self {
id: row.get::<_, i32>("id") as u32,
user_id: row.get::<_, i32>("user_id") as u32,
group_id: row.get::<_, i32>("group_id") as u32,
}
}
}
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
pub struct AuthGroupRecord {
pub id: u32,
pub name: String,
}
pub const AUTH_GROUP_TABLE_NAME: TableName = TableName("auth_group");
impl Name for AuthGroupRecord {
fn table_name() -> TableName<'static> {
AUTH_GROUP_TABLE_NAME
}
}
impl Id for AuthGroupRecord {
fn id(&self) -> u32 {
self.id
}
}
#[cfg(feature = "postgres-interop")]
impl From<Row> for AuthGroupRecord {
fn from(row: Row) -> Self {
Self {
id: row.get::<_, i32>("id") as u32,
name: row.get("name"),
}
}
}
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
pub struct PacemakerConfigurationRecord {
pub id: u32,
pub state: String,
pub immutable_state: bool,
pub not_deleted: Option<bool>,
pub content_type_id: Option<u32>,
pub host_id: u32,
}
pub const PACEMAKER_CONFIGURATION_TABLE_NAME: TableName =
TableName("chroma_core_pacemakerconfiguration");
impl Name for PacemakerConfigurationRecord {
fn table_name() -> TableName<'static> {
PACEMAKER_CONFIGURATION_TABLE_NAME
}
}
impl Id for PacemakerConfigurationRecord {
fn id(&self) -> u32 {
self.id
}
}
impl NotDeleted for PacemakerConfigurationRecord {
fn not_deleted(&self) -> bool {
not_deleted(self.not_deleted)
}
}
impl EndpointName for PacemakerConfigurationRecord {
fn endpoint_name() -> &'static str {
"pacemaker_configuration"
}
}
impl Label for PacemakerConfigurationRecord {
fn label(&self) -> &str {
"pacemaker configuration"
}
}
impl ToCompositeId for PacemakerConfigurationRecord {
fn composite_id(&self) -> CompositeId {
CompositeId(self.content_type_id.unwrap(), self.id)
}
}
impl ToCompositeId for &PacemakerConfigurationRecord {
fn composite_id(&self) -> CompositeId {
CompositeId(self.content_type_id.unwrap(), self.id)
}
}
#[cfg(feature = "postgres-interop")]
impl From<Row> for PacemakerConfigurationRecord {
fn from(row: Row) -> Self {
Self {
id: row.get::<_, i32>("id") as u32,
state: row.get("state"),
immutable_state: row.get("immutable_state"),
not_deleted: row.get("not_deleted"),
content_type_id: row
.get::<_, Option<i32>>("content_type_id")
.map(|x| x as u32),
host_id: row.get::<_, i32>("host_id") as u32,
}
}
}
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone, PartialEq, Eq)]
pub struct CorosyncConfigurationRecord {
pub id: u32,
pub state: String,
pub immutable_state: bool,
pub not_deleted: Option<bool>,
pub mcast_port: Option<u32>,
pub corosync_reported_up: bool,
pub content_type_id: Option<u32>,
pub host_id: u32,
}
pub const COROSYNC_CONFIGURATION_TABLE_NAME: TableName =
TableName("chroma_core_corosyncconfiguration");
impl Name for CorosyncConfigurationRecord {
fn table_name() -> TableName<'static> {
COROSYNC_CONFIGURATION_TABLE_NAME
}
}
impl Id for CorosyncConfigurationRecord {
fn id(&self) -> u32 {
self.id
}
}
impl NotDeleted for CorosyncConfigurationRecord {
fn not_deleted(&self) -> bool {
not_deleted(self.not_deleted)
}
}
impl EndpointName for CorosyncConfigurationRecord {
fn endpoint_name() -> &'static str {
"corosync_configuration"
}
}
impl Label for CorosyncConfigurationRecord {
fn label(&self) -> &str {
"corosync configuration"
}
}
impl ToCompositeId for CorosyncConfigurationRecord {
fn composite_id(&self) -> CompositeId {
CompositeId(self.content_type_id.unwrap(), self.id)
}
}
impl ToCompositeId for &CorosyncConfigurationRecord {
fn composite_id(&self) -> CompositeId {
CompositeId(self.content_type_id.unwrap(), self.id)
}
}
#[cfg(feature = "postgres-interop")]
impl From<Row> for CorosyncConfigurationRecord {
fn from(row: Row) -> Self {
Self {
id: row.get::<_, i32>("id") as u32,
state: row.get("state"),
immutable_state: row.get("immutable_state"),
not_deleted: row.get("not_deleted"),
mcast_port: row.get::<_, Option<i32>>("mcast_port").map(|x| x as u32),
corosync_reported_up: row.get("corosync_reported_up"),
content_type_id: row
.get::<_, Option<i32>>("content_type_id")
.map(|x| x as u32),
host_id: row.get::<_, i32>("host_id") as u32,
}
}
}