jmx 0.2.1

JMX client library 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

use failure::ResultExt;
use j4rs::Instance;
use j4rs::Jvm;

use super::ErrorKind;
use super::Result;

use super::constants::JMX_MBEAN_ATTRIBUTE_INFO;
use super::constants::JMX_MBEAN_FEATURE_INFO;

use super::util::to_vec;


/// Metadata about an MBean attribute.
///
/// Rust version of `javax.management.MBeanAttributeInfo`
#[derive(Clone, Eq, PartialEq, Ord, PartialOrd, Hash, Debug, Serialize, Deserialize)]
pub struct MBeanAttribute {
    pub description: String,
    // descriptor
    pub is_is: bool,
    pub is_readable: bool,
    pub is_writable: bool,
    pub name: String,
    pub type_name: String,
}

impl MBeanAttribute {
    /// Create an `MBeanAttribute` instance from a `javax.management.MBeanAttributeInfo`
    /// java instance.
    pub fn from_instance(jvm: &Jvm, instance: Instance) -> Result<MBeanAttribute> {
        let is_is = jvm.invoke(&instance, "isIs", &vec![]).with_context(
            |_| ErrorKind::JavaInvoke(instance.class_name().to_string(), "isIs")
        )?;
        let is_is: bool = jvm.to_rust(is_is)
            .with_context(|_| ErrorKind::RustCast("bool"))?;
        let is_readable = jvm.invoke(&instance, "isReadable", &vec![]).with_context(
            |_| ErrorKind::JavaInvoke(instance.class_name().to_string(), "isReadable")
        )?;
        let is_readable: bool = jvm.to_rust(is_readable)
            .with_context(|_| ErrorKind::RustCast("bool"))?;
        let is_writable = jvm.invoke(&instance, "isWritable", &vec![]).with_context(
            |_| ErrorKind::JavaInvoke(instance.class_name().to_string(), "isWritable")
        )?;
        let is_writable: bool = jvm.to_rust(is_writable)
            .with_context(|_| ErrorKind::RustCast("bool"))?;
        let type_name = jvm.invoke(&instance, "getType", &vec![]).with_context(
            |_| ErrorKind::JavaInvoke(instance.class_name().to_string(), "getType")
        )?;
        let type_name: String = jvm.to_rust(type_name)
            .with_context(|_| ErrorKind::RustCast("String"))?;

        // Cast to javax.management.MBeanFeatureInfo for the other attributes.
        let instance = jvm.cast(&instance, JMX_MBEAN_FEATURE_INFO)
            .with_context(|_| ErrorKind::JavaCast(JMX_MBEAN_FEATURE_INFO.to_string()))?;
        let description = jvm.invoke(&instance, "getDescription", &vec![]).with_context(
            |_| ErrorKind::JavaInvoke(instance.class_name().to_string(), "getDescription")
        )?;
        let description: String = jvm.to_rust(description)
            .with_context(|_| ErrorKind::RustCast("String"))?;
        let name = jvm.invoke(&instance, "getName", &vec![]).with_context(
            |_| ErrorKind::JavaInvoke(instance.class_name().to_string(), "getName")
        )?;
        let name: String = jvm.to_rust(name).with_context(|_| ErrorKind::RustCast("String"))?;
        Ok(MBeanAttribute {
            description,
            is_is,
            is_readable,
            is_writable,
            name,
            type_name,
        })
    }
}


/// Metadata about an MBean.
///
/// Rust version of `javax.management.MBeanInfo`
#[derive(Clone, Eq, PartialEq, Ord, PartialOrd, Hash, Debug, Serialize, Deserialize)]
pub struct MBeanInfo {
    pub attributes: Vec<MBeanAttribute>,
    pub class_name: String,
    // constructor,
    pub description: String,
    // descriptor,
    // notifications,
    // operations,
}

impl MBeanInfo {
    /// Create an `MBeanInfo` instance from a `javax.management.MBeanInfo` java instance.
    pub fn from_instance(jvm: &Jvm, instance: Instance) -> Result<MBeanInfo> {
        let attributes = MBeanInfo::attributes_from_instance(jvm, &instance)?;
        let class_name = jvm.invoke(&instance, "getClassName", &vec![]).with_context(
            |_| ErrorKind::JavaInvoke(instance.class_name().to_string(), "getClassName")
        )?;
        let class_name: String = jvm.to_rust(class_name)
            .with_context(|_| ErrorKind::RustCast("String"))?;
        let description = jvm.invoke(&instance, "getDescription", &vec![]).with_context(
            |_| ErrorKind::JavaInvoke(instance.class_name().to_string(), "getDescription")
        )?;
        let description: String = jvm.to_rust(description)
            .with_context(|_| ErrorKind::RustCast("String"))?;
        Ok(MBeanInfo {
            attributes,
            class_name,
            description,
        })
    }
}

impl MBeanInfo {
    fn attributes_from_instance(jvm: &Jvm, instance: &Instance) -> Result<Vec<MBeanAttribute>> {
        let raw = jvm.invoke(instance, "getAttributes", &vec![]).with_context(
            |_| ErrorKind::JavaInvoke(instance.class_name().to_string(), "getAttributes")
        )?;
        let raw = to_vec(jvm, raw, JMX_MBEAN_ATTRIBUTE_INFO)?;
        let mut attributes = Vec::new();
        for instance in raw {
            attributes.push(MBeanAttribute::from_instance(jvm, instance)?);
        }
        Ok(attributes)
    }
}