sfa.rs

// Copyright (c) 2020 DDN. All rights reserved.
// Use of this source code is governed by a MIT-style
// license that can be found in the LICENSE file.

pub use crate::models::{ChromaCoreSfastoragesystem, EnclosureType, HealthState, MemberState};
#[cfg(feature = "postgres-interop")]
use crate::{
    schema::{
        chroma_core_sfadiskdrive as sd, chroma_core_sfadiskdrive, chroma_core_sfaenclosure as se,
        chroma_core_sfaenclosure, chroma_core_sfastoragesystem as ss, chroma_core_sfastoragesystem,
    },
    Executable,
};
#[cfg(feature = "postgres-interop")]
use diesel::{pg::upsert::excluded, prelude::*};
#[cfg(feature = "wbem-interop")]
use std::convert::{TryFrom, TryInto};
#[cfg(feature = "wbem-interop")]
use thiserror::Error;
#[cfg(feature = "wbem-interop")]
use wbem_client::{
    resp::{Cim, IReturnValueInstance, Instance},
    CimXmlError,
};

#[cfg(feature = "wbem-interop")]
#[derive(Error, Debug)]
pub enum SfaClassError {
    #[error(transparent)]
    CimXmlError(#[from] CimXmlError),
    #[error("Expected class {0}, found class {1}")]
    UnexpectedInstance(&'static str, String),
    #[error("HealthState {0} not known")]
    UnknownHealth(String),
    #[error("Enclosure Type {0} not known")]
    UnknownEnclosure(String),
    #[error("MemberState {0} not known")]
    UnknownMemberState(String),
    #[error(transparent)]
    ParseBoolError(#[from] std::str::ParseBoolError),
    #[error(transparent)]
    ParseIntError(#[from] std::num::ParseIntError),
}

#[cfg(feature = "wbem-interop")]
impl<'a> TryFrom<&'a str> for EnclosureType {
    type Error = SfaClassError;

    fn try_from(s: &str) -> Result<Self, Self::Error> {
        match s {
            "0" => Ok(EnclosureType::None),
            "1" => Ok(EnclosureType::Disk),
            "2" => Ok(EnclosureType::Controller),
            "3" => Ok(EnclosureType::Ups),
            "255" => Ok(EnclosureType::Unknown),
            x => Err(SfaClassError::UnknownEnclosure(x.into())),
        }
    }
}

#[cfg(feature = "wbem-interop")]
impl<'a> TryFrom<&'a str> for HealthState {
    type Error = SfaClassError;

    fn try_from(s: &str) -> Result<Self, Self::Error> {
        match s {
            "0" => Ok(HealthState::None),
            "1" => Ok(HealthState::Ok),
            "2" => Ok(HealthState::NonCritical),
            "3" => Ok(HealthState::Critical),
            "255" => Ok(HealthState::Unknown),
            x => Err(SfaClassError::UnknownHealth(x.into())),
        }
    }
}

#[derive(Debug, Clone)]
#[cfg_attr(
    feature = "postgres-interop",
    derive(Queryable, Insertable, AsChangeset, Identifiable)
)]
#[cfg_attr(feature = "postgres-interop", primary_key(index))]
#[cfg_attr(feature = "postgres-interop", table_name = "chroma_core_sfaenclosure")]
pub struct SfaEnclosure {
    /// Specifies the index, part of the OID, of the enclosure.
    pub index: i32,
    pub element_name: String,
    pub health_state: HealthState,
    pub position: i16,
    pub enclosure_type: EnclosureType,
    pub storage_system: Option<String>,
}

pub type Table = se::table;

#[cfg(feature = "postgres-interop")]
impl SfaEnclosure {
    pub fn all() -> Table {
        se::table
    }
    pub fn batch_upsert(xs: Vec<Self>) -> impl Executable {
        diesel::insert_into(Self::all())
            .values(xs)
            .on_conflict(se::index)
            .do_update()
            .set((
                se::element_name.eq(excluded(se::element_name)),
                se::health_state.eq(excluded(se::health_state)),
                se::position.eq(excluded(se::position)),
                se::enclosure_type.eq(excluded(se::enclosure_type)),
                se::storage_system.eq(excluded(se::storage_system)),
            ))
    }
    pub fn upsert(self) -> impl Executable {
        diesel::insert_into(se::table)
            .values(self.clone())
            .on_conflict(se::index)
            .do_update()
            .set(self)
    }
}

#[derive(Debug, Clone)]
#[cfg_attr(
    feature = "postgres-interop",
    derive(Queryable, Insertable, AsChangeset)
)]
#[cfg_attr(
    feature = "postgres-interop",
    table_name = "chroma_core_sfastoragesystem"
)]
pub struct SfaStorageSystem {
    pub child_health_state: HealthState,
    pub health_state_reason: String,
    pub health_state: HealthState,
    pub uuid: String,
}

#[cfg(feature = "wbem-interop")]
impl TryFrom<Instance> for SfaEnclosure {
    type Error = SfaClassError;

    fn try_from(x: Instance) -> Result<Self, Self::Error> {
        if x.class_name != "DDN_SFAEnclosure" {
            return Err(SfaClassError::UnexpectedInstance(
                "DDN_SFAEnclosure",
                x.class_name.to_string(),
            ));
        }

        Ok(SfaEnclosure {
            index: x.try_get_property("Index")?.parse::<i32>()?,
            element_name: x.try_get_property("ElementName")?.into(),
            health_state: x.try_get_property("HealthState")?.try_into()?,
            position: x.try_get_property("Position")?.parse::<i16>()?,
            enclosure_type: x.try_get_property("Type")?.try_into()?,
            storage_system: None,
        })
    }
}

#[cfg(feature = "postgres-interop")]
impl SfaStorageSystem {
    pub fn upsert(x: Self) -> impl Executable {
        diesel::insert_into(ss::table)
            .values(x.clone())
            .on_conflict(ss::uuid)
            .do_update()
            .set(x)
    }
}

#[cfg(feature = "wbem-interop")]
impl TryFrom<Instance> for SfaStorageSystem {
    type Error = SfaClassError;

    fn try_from(x: Instance) -> Result<Self, Self::Error> {
        if x.class_name != "DDN_SFAStorageSystem" {
            return Err(SfaClassError::UnexpectedInstance(
                "DDN_SFAStorageSystem",
                x.class_name.to_string(),
            ));
        }

        Ok(SfaStorageSystem {
            child_health_state: x.try_get_property("ChildHealthState")?.try_into()?,
            health_state_reason: x.try_get_property("HealthStateReason")?.into(),
            health_state: x.try_get_property("HealthState")?.try_into()?,
            uuid: x.try_get_property("UUID")?.into(),
        })
    }
}

#[cfg(feature = "wbem-interop")]
impl TryFrom<Cim<IReturnValueInstance>> for SfaStorageSystem {
    type Error = SfaClassError;

    fn try_from(x: Cim<IReturnValueInstance>) -> Result<Self, Self::Error> {
        let x = x.message.simplersp.imethodresponse.i_return_value.instance;

        SfaStorageSystem::try_from(x)
    }
}

#[cfg(feature = "wbem-interop")]
impl<'a> TryFrom<&'a str> for MemberState {
    type Error = SfaClassError;

    fn try_from(x: &str) -> Result<Self, Self::Error> {
        match x {
            "0" => Ok(Self::MemberStateNormal),
            "1" => Ok(Self::MemberStateMissing),
            "2" => Ok(Self::MemberStateAlreadyMissing),
            "3" => Ok(Self::MemberStateRebuilding),
            "4" => Ok(Self::MemberStateWaitingToRebuild),
            "5" => Ok(Self::MemberStateFailed),
            "6" => Ok(Self::MemberStateMissingNoRebuild),
            "7" => Ok(Self::MemberStateErrorRec),
            "8" => Ok(Self::MemberStateUnassigned),
            "9" => Ok(Self::MemberStateCopyback),
            "10" => Ok(Self::MemberStateWaitingCopyback),
            "11" => Ok(Self::MemberStateLocked),
            "12" => Ok(Self::MemberStateLockedNoRebuild),
            "13" => Ok(Self::MemberStateAlreadyLocked),
            "14" => Ok(Self::MemberStateMissingPreventsRebuild),
            "15" => Ok(Self::MemberStateLockedPreventsRebuild),
            "255" => Ok(Self::MemberStateUnknown),
            x => Err(SfaClassError::UnknownMemberState(x.into())),
        }
    }
}

#[derive(Debug, Clone, Eq, PartialEq, Ord, PartialOrd)]
#[cfg_attr(
    feature = "postgres-interop",
    derive(Queryable, Insertable, AsChangeset)
)]
#[cfg_attr(feature = "postgres-interop", primary_key(index))]
#[cfg_attr(feature = "postgres-interop", table_name = "chroma_core_sfadiskdrive")]
pub struct SfaDiskDrive {
    pub index: i16,
    pub child_health_state: HealthState,
    pub failed: bool,
    pub health_state_reason: String,
    pub slot_number: i32,
    pub health_state: HealthState,
    /// Specifies the member index of the disk drive.
    /// If the disk drive is not a member of a pool, this value will be not be set.
    pub member_index: Option<i16>,
    /// Specifies the state of the disk drive relative to a containing pool.
    pub member_state: MemberState,
    pub enclosure_index: i32,
}

#[cfg(feature = "postgres-interop")]
impl SfaDiskDrive {
    pub fn all() -> sd::table {
        sd::table
    }
    pub fn batch_upsert(xs: Vec<Self>) -> impl Executable {
        diesel::insert_into(Self::all())
            .values(xs)
            .on_conflict(sd::index)
            .do_update()
            .set((
                sd::child_health_state.eq(excluded(sd::child_health_state)),
                sd::failed.eq(excluded(sd::failed)),
                sd::health_state_reason.eq(excluded(sd::health_state_reason)),
                sd::health_state.eq(excluded(sd::health_state)),
                sd::member_index.eq(excluded(sd::member_index)),
                sd::member_state.eq(excluded(sd::member_state)),
                sd::enclosure_index.eq(excluded(sd::enclosure_index)),
            ))
    }
    pub fn batch_remove(xs: Vec<i16>) -> impl Executable {
        diesel::delete(Self::all()).filter(sd::index.eq_any(xs))
    }
}

#[cfg(feature = "wbem-interop")]
impl TryFrom<Instance> for SfaDiskDrive {
    type Error = SfaClassError;

    fn try_from(x: Instance) -> Result<Self, Self::Error> {
        if x.class_name != "DDN_SFADiskDrive" {
            return Err(SfaClassError::UnexpectedInstance(
                "DDN_SFADiskDrive",
                x.class_name.to_string(),
            ));
        }

        Ok(SfaDiskDrive {
            index: x.try_get_property("Index")?.parse::<i16>()?,
            child_health_state: x.try_get_property("ChildHealthState")?.try_into()?,
            enclosure_index: x.try_get_property("EnclosureIndex")?.parse::<i32>()?,
            failed: x
                .try_get_property("Failed")?
                .to_lowercase()
                .parse::<bool>()?,
            health_state_reason: x.try_get_property("HealthStateReason")?.into(),
            health_state: x.try_get_property("HealthState")?.try_into()?,
            member_index: x
                .get_property("MemberIndex")
                .map(|x| x.parse::<i16>())
                .transpose()?,
            member_state: x.try_get_property("MemberState")?.try_into()?,
            slot_number: x.try_get_property("DiskSlotNumber")?.parse::<i32>()?,
        })
    }
}

pub struct SfaStoragePool {}

pub struct SfaVirtualDisk {}