Enum kuma_client::monitor::Monitor

pub enum Monitor {
    Group {
        value: MonitorGroup,
    },
    Http {
        value: MonitorHttp,
    },
    Port {
        value: MonitorPort,
    },
    Ping {
        value: MonitorPing,
    },
    Keyword {
        value: MonitorKeyword,
    },
    JsonQuery {
        value: MonitorJsonQuery,
    },
    GrpcKeyword {
        value: MonitorGrpcKeyword,
    },
    Dns {
        value: MonitorDns,
    },
    Docker {
        value: MonitorDocker,
    },
    RealBrowser {
        value: MonitorRealBrowser,
    },
    Push {
        value: MonitorPush,
    },
    Steam {
        value: MonitorSteam,
    },
    GameDig {
        value: MonitorGameDig,
    },
    Mqtt {
        value: MonitorMqtt,
    },
    KafkaProducer {
        value: MonitorKafkaProducer,
    },
    SqlServer {
        value: MonitorSqlServer,
    },
    Postgres {
        value: MonitorPostgres,
    },
    Mysql {
        value: MonitorMysql,
    },
    Mongodb {
        value: MonitorMongoDB,
    },
    Radius {
        value: MonitorRadius,
    },
    Redis {
        value: MonitorRedis,
    },
    TailscalePing {
        value: MonitorTailscalePing,
    },
}

Variants

Group

Fields

value: MonitorGroup

Http

Fields

value: MonitorHttp

Port

Fields

value: MonitorPort

Ping

Fields

value: MonitorPing

Keyword

Fields

value: MonitorKeyword

JsonQuery

Fields

value: MonitorJsonQuery

GrpcKeyword

Fields

value: MonitorGrpcKeyword

Dns

Fields

value: MonitorDns

Docker

Fields

value: MonitorDocker

RealBrowser

Fields

value: MonitorRealBrowser

Push

Fields

value: MonitorPush

Steam

Fields

value: MonitorSteam

GameDig

Fields

value: MonitorGameDig

Mqtt

Fields

value: MonitorMqtt

KafkaProducer

Fields

value: MonitorKafkaProducer

SqlServer

Fields

value: MonitorSqlServer

Postgres

Fields

value: MonitorPostgres

Mysql

Fields

value: MonitorMysql

Mongodb

Fields

value: MonitorMongoDB

Radius

Fields

value: MonitorRadius

Redis

Fields

value: MonitorRedis

TailscalePing

Fields

value: MonitorTailscalePing

Implementations

impl Monitor

pub fn monitor_type(&self) -> MonitorType

pub fn common(&self) -> Box<&dyn MonitorCommon>

Examples found in repository

examples/create_monitor.rs (line 62)

async fn main() {
    // Connect to the server
    let client = Client::connect(Config {
        url: Url::parse("http://localhost:3001").expect("Invalid URL"),
        username: Some("Username".to_owned()),
        password: Some("Password".to_owned()),
        ..Default::default()
    })
    .await
    .expect("Failed to connect to server");

    // Create a tag
    let tag_definition = client
        .add_tag(TagDefinition {
            name: Some("example_tag".to_owned()),
            color: Some("red".to_owned()),
            ..Default::default()
        })
        .await
        .expect("Failed to add tag");

    // Create a group
    let group = client
        .add_monitor(MonitorGroup {
            name: Some("Example Group".to_owned()),
            tags: vec![Tag {
                tag_id: tag_definition.tag_id,
                value: Some("example_group".to_owned()),
                ..Default::default()
            }],
            ..Default::default()
        })
        .await
        .expect("Failed to add group");

    // Createa a notification
    let notification = client
        .add_notification(Notification {
            name: Some("Example Notification".to_owned()),
            config: Some(serde_json::json!({
                "webhookURL": "https://webhook.site/304eeaf2-0248-49be-8985-2c86175520ca",
                "webhookContentType": "json"
            })),
            ..Default::default()
        })
        .await
        .expect("Failed to add notification");

    // Create a monitor
    client
        .add_monitor(MonitorHttp {
            name: Some("Monitor Name".to_owned()),
            url: Some("https://example.com".to_owned()),
            parent: group.common().id().clone(),
            tags: vec![Tag {
                tag_id: tag_definition.tag_id,
                value: Some("example_monitor".to_owned()),
                ..Default::default()
            }],
            notification_id_list: Some(
                vec![(
                    notification.id.expect("No notification ID").to_string(),
                    true,
                )]
                .into_iter()
                .collect(),
            ),
            ..Default::default()
        })
        .await
        .expect("Failed to add monitor");

    let monitors = client.get_monitors().await.expect("Failed to get monitors");
    println!("{:?}", monitors);
}

pub fn common_mut(&mut self) -> Box<&mut dyn MonitorCommon>

pub fn validate(&self, id: impl AsRef<str>) -> Result<()>

Trait Implementations

impl Clone for Monitor

fn clone(&self) -> Monitor

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Monitor

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Monitor

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<MonitorDns> for Monitor

fn from(value: MonitorDns) -> Self

Converts to this type from the input type.

impl From<MonitorDocker> for Monitor

fn from(value: MonitorDocker) -> Self

Converts to this type from the input type.

impl From<MonitorGameDig> for Monitor

fn from(value: MonitorGameDig) -> Self

Converts to this type from the input type.

impl From<MonitorGroup> for Monitor

fn from(value: MonitorGroup) -> Self

Converts to this type from the input type.

impl From<MonitorGrpcKeyword> for Monitor

fn from(value: MonitorGrpcKeyword) -> Self

Converts to this type from the input type.

impl From<MonitorHttp> for Monitor

fn from(value: MonitorHttp) -> Self

Converts to this type from the input type.

impl From<MonitorJsonQuery> for Monitor

fn from(value: MonitorJsonQuery) -> Self

Converts to this type from the input type.

impl From<MonitorKafkaProducer> for Monitor

fn from(value: MonitorKafkaProducer) -> Self

Converts to this type from the input type.

impl From<MonitorKeyword> for Monitor

fn from(value: MonitorKeyword) -> Self

Converts to this type from the input type.

impl From<MonitorMongoDB> for Monitor

fn from(value: MonitorMongoDB) -> Self

Converts to this type from the input type.

impl From<MonitorMqtt> for Monitor

fn from(value: MonitorMqtt) -> Self

Converts to this type from the input type.

impl From<MonitorMysql> for Monitor

fn from(value: MonitorMysql) -> Self

Converts to this type from the input type.

impl From<MonitorPing> for Monitor

fn from(value: MonitorPing) -> Self

Converts to this type from the input type.

impl From<MonitorPort> for Monitor

fn from(value: MonitorPort) -> Self

Converts to this type from the input type.

impl From<MonitorPostgres> for Monitor

fn from(value: MonitorPostgres) -> Self

Converts to this type from the input type.

impl From<MonitorPush> for Monitor

fn from(value: MonitorPush) -> Self

Converts to this type from the input type.

impl From<MonitorRadius> for Monitor

fn from(value: MonitorRadius) -> Self

Converts to this type from the input type.

impl From<MonitorRealBrowser> for Monitor

fn from(value: MonitorRealBrowser) -> Self

Converts to this type from the input type.

impl From<MonitorRedis> for Monitor

fn from(value: MonitorRedis) -> Self

Converts to this type from the input type.

impl From<MonitorSqlServer> for Monitor

fn from(value: MonitorSqlServer) -> Self

Converts to this type from the input type.

impl From<MonitorSteam> for Monitor

fn from(value: MonitorSteam) -> Self

Converts to this type from the input type.

impl From<MonitorTailscalePing> for Monitor

fn from(value: MonitorTailscalePing) -> Self

Converts to this type from the input type.

impl PartialEq for Monitor

fn eq(&self, other: &Monitor) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Monitor

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Monitor