Update

Author: Chris Jones

examples/ceph.rs

@@ -17,24 +17,14 @@
 extern crate ceph_rust;
 extern crate libc;
 
-use libc::*;
-use std::ffi::{CStr, CString};
-use std::{ptr, str, slice};
 
+use ceph_rust::JsonData;
+#[cfg(target_os = "linux")]
+use ceph_rust::admin_sockets::*;
 #[cfg(target_os = "linux")]
 use ceph_rust::ceph as ceph_helpers;
 #[cfg(target_os = "linux")]
 use ceph_rust::rados as ceph;
-#[cfg(target_os = "linux")]
-use ceph_rust::admin_sockets::*;
-
-use ceph_rust::JsonData;
-
-macro_rules! zeroed_c_char_buf {
-	($n:expr) => {
-		repeat(0).take($n).collect::<Vec<c_char>>();
-	}
-}
 
 #[cfg(not(target_os = "linux"))]
 fn main() {}
@@ -43,50 +33,87 @@ fn main() {}
 
 #[cfg(target_os = "linux")]
 fn main() {
-    let mut major: i32 = 0;
-    let mut minor: i32 = 0;
-    let mut extra: i32 = 0;
-
-    let config_file = CString::new("/etc/ceph/ceph.conf").unwrap();
-    let pool_name = CString::new("lsio").unwrap();
-    let mut cluster: ceph::rados_t = std::ptr::null_mut();
-    let mut ret_code: i32;
-
+    let pool_name = "lsio";
     // NB: These examples (except for a few) are low level examples that require the unsafe block.
     // However, work for the higher level pur Rust is being worked on in the ceph.rs module of
     // the library. A few of those are present below. We will create a common Result or Option
     // return and allow for pattern matching.
 
     // Example of accessing the `Admin Socket` for mon
-    match admin_socket_command("help", "/var/run/ceph/ceph-mon.ceph-vm1.asok") {
+    match admin_socket_command("help", "/var/run/ceph/ceph-mon.ip-172-31-31-247.asok") {
         Ok(json) => {
             println!("{}", json);
         },
-        Err(e) => { println!("{}", e); },
+        Err(e) => {
+            println!("{}", e);
+        },
     }
 
-    unsafe {
-        ceph::rados_version(&mut major, &mut minor, &mut extra);
-        ret_code = ceph::rados_create(&mut cluster, std::ptr::null());
-        println!("Return code: {} - {:?}", ret_code, cluster);
+    let rados_version = ceph_helpers::rados_libversion();
+    println!("Librados version: {:?}", rados_version);
 
-        ret_code = ceph::rados_conf_read_file(cluster, config_file.as_ptr());
-        println!("Return code: {} - {:?}", ret_code, cluster);
+    println!("Connecting to ceph");
+    let cluster = ceph_helpers::connect_to_ceph("admin", "/etc/ceph/ceph.conf").unwrap();
+    println!("Creating pool {}", pool_name);
+    ceph_helpers::rados_create_pool(cluster, pool_name).unwrap();
 
-        ret_code = ceph::rados_connect(cluster);
-        println!("Return code: {} - {:?}", ret_code, cluster);
-
-        ret_code = ceph::rados_pool_create(cluster, pool_name.as_ptr());
-        println!("Return code: {}", ret_code);
+    println!("Listing pools");
+    let pools_list = ceph_helpers::rados_pools(cluster).unwrap();
+	for pool in pools_list{
+		println!("pool: {}", pool);
+	}
 
-        let pools_list = ceph_helpers::rados_pools(cluster).unwrap();
-        println!("{:?}", pools_list);
+    println!("Deleting pool: {}", pool_name);
+    ceph_helpers::rados_delete_pool(cluster, pool_name).unwrap();
+
+    println!("Getting cluster fsid");
+    let fsid = ceph_helpers::rados_fsid(cluster);
+    println!("rados_cluster_fsid {:?}", fsid);
+
+    let cluster_stat = ceph_helpers::rados_stat_cluster(cluster).unwrap();
+    println!("Cluster stat: {:?}", cluster_stat);
+
+    // Print CephHealth of cluster
+    println!("{}", ceph_helpers::ceph_health_string(cluster).unwrap_or("".to_string()));
+
+    // Print Status of cluster health a different way
+    println!("{}", ceph_helpers::ceph_status(cluster, &["health", "overall_status"]).unwrap());
+    // Currently - parses the `ceph --version` call. The admin socket commands `version`
+    // and `git_version`
+    // will be called soon to replace the string parse.
+    // Change to the real mon admin socket name
+    let ceph_ver = ceph_helpers::ceph_version("/var/run/ceph/ceph-mon.ip-172-31-31-247.asok");
+    println!("Ceph Version - {:?}", ceph_ver);
+    // Mon command to check the health. Same as `ceph -s`
+    match ceph_helpers::ceph_mon_command(cluster, "prefix", "status", None) {
+        Ok((outbuf, outs)) => {
+            match outbuf {
+                Some(output) => println!("Ceph mon command (outbuf):\n{}", output),
+                None => {},
+            }
+            match outs {
+                Some(output) => println!("Ceph mon command (outs):\n{}", output),
+                None => {},
+            }
+        },
+        Err(e) => {
+            println!("{:?}", e);
+        },
+    }
 
-        ret_code = ceph::rados_pool_delete(cluster, pool_name.as_ptr());
-        println!("Return code: {}", ret_code);
+    // This command encapsulates the lower level mon, osd, pg commands and returns JsonData
+    // objects based on the key path
+    println!("{:?}",
+             ceph_helpers::ceph_command(cluster, "prefix", "status", ceph_helpers::CephCommandTypes::Mon, &["health"]));
 
+    // Get a list of Ceph librados commands in JSON format.
+    // It's very long so it's commented out.
+    // println!("{}", ceph_helpers::ceph_commands(cluster, None).unwrap().pretty());
+    unsafe {
+		println!("Getting rados instance id");
         let instance_id = ceph::rados_get_instance_id(cluster);
         println!("Instance ID: {}", instance_id);
+<<<<<<< HEAD
 
         let buf_size: usize = 37; // 36 is the constant size +1 for null.
         let mut fs_id: Vec<u8> = Vec::with_capacity(buf_size);
@@ -137,8 +164,10 @@ fn main() {
         println!("Ceph Version - {:?}", ceph_ver);
 
         ceph::rados_shutdown(cluster);
+=======
+>>>>>>> 35d831707aa957a5375e64ab1e36a1d83b57e5ee
     }
 
-    println!("RADOS Version - v{}.{}.{}", major, minor, extra);
-
+    ceph_helpers::disconnect_from_ceph(cluster);
+    println!("RADOS Version - v{}.{}.{}", rados_version.major, rados_version.minor, rados_version.extra);
 }

src/admin_sockets.rs

@@ -19,20 +19,20 @@ use std::io::{Read, Write, Cursor};
 use std::os::unix::net::UnixStream;
 use std::net::Shutdown;
 
-use error::RadosError;
+use error::{RadosError, RadosResult};
 use byteorder::{BigEndian, ReadBytesExt};
 
 /// This is a helper function that builds a raw command from the actual command. You just pass
 /// in a command like "help". The returned `String` will be a JSON String.
-pub fn admin_socket_command(cmd: &str, socket: &str) -> Result<String, RadosError> {
+pub fn admin_socket_command(cmd: &str, socket: &str) -> RadosResult<String> {
     let raw_cmd = format!("{{\"{}\": \"{}\"}}", "prefix", cmd);
     admin_socket_raw_command(&raw_cmd, socket)
 }
 
 /// This function supports a raw command in the format of something like: `{"prefix": "help"}`.
 /// The returned `String` will be a JSON String.
 #[allow(unused_variables)]
-pub fn admin_socket_raw_command(cmd: &str, socket: &str) -> Result<String, RadosError> {
+pub fn admin_socket_raw_command(cmd: &str, socket: &str) -> RadosResult<String> {
     let mut output = String::new();
     let mut buffer = vec![0;4];  // Should return 4 bytes with size or indicator.
     let cmd = &format!("{}\0", cmd);  // Terminator so don't add one to commands.