[#2] Add python api

Author: uhmh123

curvine-libsdk/src/python/mod.rs

@@ -0,0 +1,3 @@
+mod python_filesystem;
+pub mod python_abi;
+pub use self::python_filesystem::PythonFilesystem;

curvine-libsdk/src/python/python_abi.rs

@@ -0,0 +1,246 @@
+#![allow(clippy::missing_safety_doc)]
+
+use crate::{LibFsReader, LibFsWriter};
+use crate::python::PythonFilesystem;
+use orpc::sys::DataSlice;
+use orpc::sys::{FFIUtils, RawVec};
+use pyo3::prelude::*; 
+use pyo3::types::{PyList, PyBytes};
+
+
+#[pyfunction] 
+pub fn python_io_curvine_curvine_native_new_filesystem(conf: String) -> PyResult<i64>{
+    let fs = PythonFilesystem::new(conf)?;
+    Ok(FFIUtils::into_raw_ptr(fs))
+}
+
+#[pyfunction]
+pub fn python_io_curvine_curvine_native_create(
+    bound_fs: &Bound<'_, PythonFilesystem>,
+    path: String,
+    overwrite: bool
+) -> PyResult<i64>{
+
+    let raw_ptr = bound_fs.as_ptr();
+    let fs_ptr = raw_ptr.cast::<PythonFilesystem>();
+    let fs = unsafe{ &*fs_ptr};
+    let writer = fs.create(path,overwrite)?;
+    Ok(FFIUtils::into_raw_ptr(writer))
+}
+
+#[pyfunction]
+pub fn python_io_curvine_curvine_native_append(
+    bound_fs: &Bound<'_, PythonFilesystem>,
+    path: String,
+    tmp: &Bound<'_, PyList>,
+) -> PyResult<i64>{
+    let raw_ptr = bound_fs.as_ptr();
+    let fs_ptr = raw_ptr.cast::<PythonFilesystem>();
+    let fs = unsafe{ &*fs_ptr};
+    let writer = fs.append(path)?; 
+    let arr = writer.pos();
+    
+    tmp.set_item(0, arr)?;  
+    Ok(FFIUtils::into_raw_ptr(writer))
+}
+
+#[pyfunction]
+pub fn python_io_curvine_curvine_native_write(
+    bound_writer: &Bound<'_, LibFsWriter>,
+    buf: i64,  
+    len: i32,
+) -> PyResult<()>{
+    let raw_ptr = bound_writer.as_ptr();
+    let writer_ptr = raw_ptr.cast::<LibFsWriter>();
+    let writer = unsafe{ &mut *writer_ptr};
+    let raw_vec = RawVec::from_raw(buf as *mut u8, len as usize);
+    let buf = DataSlice::MemSlice(raw_vec);
+    writer.write(buf)?;
+
+    Ok(())
+}
+
+#[pyfunction]
+pub fn python_io_curvine_curvine_native_flush(bound_writer: &Bound<'_, LibFsWriter>) -> PyResult<()>{
+    let raw_ptr = bound_writer.as_ptr();
+    let writer_ptr = raw_ptr.cast::<LibFsWriter>();
+    let writer = unsafe{ &mut *writer_ptr};
+    writer.flush()?;
+    Ok(())
+}
+
+#[pyfunction]
+pub unsafe fn python_io_curvine_curvine_native_close_writer(bound_writer: &Bound<'_, LibFsWriter>) -> PyResult<()>{
+    let raw_ptr = bound_writer.as_ptr();
+    let writer_ptr = raw_ptr.cast::<LibFsWriter>();
+    let writer = &mut *writer_ptr;
+    writer.complete()?;
+    FFIUtils::free_raw_ptr(writer_ptr);
+    Ok(())
+}
+
+#[pyfunction]
+pub fn python_io_curvine_curvine_native_open(
+    bound_fs: &Bound<'_, PythonFilesystem>,
+    path: String,
+    tmp: &Bound<'_, PyList>,
+) -> PyResult<i64>{
+    let raw_ptr = bound_fs.as_ptr();
+    let fs_ptr = raw_ptr.cast::<PythonFilesystem>();
+    let fs = unsafe{ &*fs_ptr};
+    let reader = fs.open(path)?;
+    let arr = reader.len();
+    tmp.set_item(0, arr)?; 
+    Ok(FFIUtils::into_raw_ptr(reader))
+}
+
+#[pyfunction]
+pub fn python_io_curvine_curvine_native_read(
+    bound_reader: &Bound<'_, LibFsReader>,
+    tmp: &Bound<'_, PyList>,
+) -> PyResult<()>{
+    let raw_ptr = bound_reader.as_ptr();
+    let reader_ptr = raw_ptr.cast::<LibFsReader>();
+    let reader = unsafe{ &mut *reader_ptr};
+    let bytes = reader.read()?; 
+
+    let bytes_ptr = bytes.as_ptr() as i64; 
+    let bytes_len = bytes.len() as i64; 
+    tmp.set_item(0, bytes_ptr)?; 
+    tmp.set_item(0, bytes_len)?; 
+    
+    Ok(())
+}
+
+#[pyfunction]
+pub fn python_io_curvine_curvine_native_seek(
+    bound_reader: &Bound<'_, LibFsReader>,
+    pos: i64,
+) -> PyResult<()>{
+    let raw_ptr = bound_reader.as_ptr();
+    let reader_ptr = raw_ptr.cast::<LibFsReader>();
+    let reader = unsafe{ &mut *reader_ptr};
+    reader.seek(pos)?;
+    Ok(())
+}
+
+#[pyfunction]
+pub unsafe fn python_io_curvine_curvine_native_close_reader(bound_reader: &Bound<'_, LibFsReader>) -> PyResult<()>{
+    let raw_ptr = bound_reader.as_ptr();
+    let reader_ptr = raw_ptr.cast::<LibFsReader>();
+    let reader = &mut *reader_ptr;
+    reader.complete()?;
+    FFIUtils::free_raw_ptr(reader_ptr);
+    Ok(()) 
+}
+
+#[pyfunction]
+pub unsafe fn python_io_curvine_curvine_native_close_filesystem(bound_fs: &Bound<'_, PythonFilesystem>) -> PyResult<()>{
+    let raw_ptr = bound_fs.as_ptr();
+    let fs_ptr = raw_ptr.cast::<PythonFilesystem>();
+    FFIUtils::free_raw_ptr(fs_ptr);
+    Ok(())
+}
+
+#[pyfunction]
+pub fn python_io_curvine_curvine_native_mkdir(
+    bound_fs: &Bound<'_, PythonFilesystem>,
+    path: String,
+    create_parent: bool,
+) -> PyResult<bool>{
+    let raw_ptr = bound_fs.as_ptr();
+    let fs_ptr = raw_ptr.cast::<PythonFilesystem>();
+    let fs = unsafe{ &*fs_ptr};
+    let is_success = fs.mkdir(path, create_parent)?;
+    Ok(is_success)
+}
+
+#[pyfunction]
+pub fn python_io_curvine_curvine_native_get_file_status<'py>(
+    bound_fs: &Bound<'py, PythonFilesystem>,
+    path: String,
+    py: Python<'py>,
+) -> PyResult<Bound<'py, PyBytes>>{
+    let raw_ptr = bound_fs.as_ptr();
+    let fs_ptr = raw_ptr.cast::<PythonFilesystem>();
+    let fs = unsafe{ &*fs_ptr};
+    let status = fs.get_file_status(path)?;
+    let bytes_data = status.freeze().to_vec();
+    Ok(PyBytes::new(py, &bytes_data))
+}
+
+#[pyfunction]
+pub fn python_io_curvine_curvine_native_list_status<'py>(
+    bound_fs: &Bound<'_, PythonFilesystem>,
+    path: String,
+    py: Python<'py>,
+) -> PyResult<Bound<'py, PyBytes>>{
+    let raw_ptr = bound_fs.as_ptr();
+    let fs_ptr = raw_ptr.cast::<PythonFilesystem>();
+    let fs = unsafe{ &*fs_ptr};
+    let status = fs.list_status(path)?;
+    let bytes_data = status.freeze().to_vec();
+    Ok(PyBytes::new(py, &bytes_data))
+}
+
+#[pyfunction]
+pub fn python_io_curvine_curvine_native_rename(
+    bound_fs: &Bound<'_, PythonFilesystem>,
+    src: String,
+    dst: String,
+) -> PyResult<bool>{
+    let raw_ptr = bound_fs.as_ptr();
+    let fs_ptr = raw_ptr.cast::<PythonFilesystem>();
+    let fs = unsafe{ &*fs_ptr};
+    let is_rename = fs.rename(src, dst)?;
+    Ok(is_rename)
+}
+
+#[pyfunction]
+pub fn python_io_curvine_curvine_native_delete(
+    bound_fs: &Bound<'_, PythonFilesystem>,
+    path: String,
+    recursive: bool,
+) -> PyResult<()>{
+    let raw_ptr = bound_fs.as_ptr();
+    let fs_ptr = raw_ptr.cast::<PythonFilesystem>();
+    let fs = unsafe{ &*fs_ptr};
+    fs.delete(path, recursive)?;
+    Ok(())
+}
+
+#[pyfunction]
+pub fn python_io_curvine_curvine_native_get_master_info<'py>(
+    bound_fs: &Bound<'_, PythonFilesystem>,
+    py: Python<'py>,
+) -> PyResult<Bound<'py, PyBytes>>{
+    let raw_ptr = bound_fs.as_ptr();
+    let fs_ptr = raw_ptr.cast::<PythonFilesystem>();
+    let fs = unsafe{ &*fs_ptr};
+    let status = fs.get_master_info()?;
+    let bytes_data = status.freeze().to_vec();
+    Ok(PyBytes::new(py, &bytes_data))
+}
+
+#[pymodule]
+fn curvine_libsdk(m: &Bound<'_, PyModule>) -> PyResult<()>{
+    m.add_function(wrap_pyfunction!(python_io_curvine_curvine_native_new_filesystem, m)?)?;
+    m.add_function(wrap_pyfunction!(python_io_curvine_curvine_native_create, m)?)?;
+    m.add_function(wrap_pyfunction!(python_io_curvine_curvine_native_append, m)?)?;
+    m.add_function(wrap_pyfunction!(python_io_curvine_curvine_native_write, m)?)?;
+    m.add_function(wrap_pyfunction!(python_io_curvine_curvine_native_flush, m)?)?;
+    m.add_function(wrap_pyfunction!(python_io_curvine_curvine_native_close_writer, m)?)?;
+    m.add_function(wrap_pyfunction!(python_io_curvine_curvine_native_open, m)?)?;
+    m.add_function(wrap_pyfunction!(python_io_curvine_curvine_native_read, m)?)?;
+    m.add_function(wrap_pyfunction!(python_io_curvine_curvine_native_seek, m)?)?;
+    m.add_function(wrap_pyfunction!(python_io_curvine_curvine_native_close_reader, m)?)?;
+    m.add_function(wrap_pyfunction!(python_io_curvine_curvine_native_close_filesystem, m)?)?;
+    m.add_function(wrap_pyfunction!(python_io_curvine_curvine_native_mkdir, m)?)?;
+    m.add_function(wrap_pyfunction!(python_io_curvine_curvine_native_get_file_status, m)?)?;
+    m.add_function(wrap_pyfunction!(python_io_curvine_curvine_native_list_status, m)?)?;
+    m.add_function(wrap_pyfunction!(python_io_curvine_curvine_native_rename, m)?)?;
+    m.add_function(wrap_pyfunction!(python_io_curvine_curvine_native_delete, m)?)?;
+    m.add_function(wrap_pyfunction!(python_io_curvine_curvine_native_get_master_info, m)?)?;
+    
+    Ok(())
+}

curvine-libsdk/src/python/python_filesystem.rs

@@ -0,0 +1,83 @@
+use crate::{FilesystemConf, LibFilesystem, LibFsReader, LibFsWriter};
+use bytes::BytesMut;
+use curvine_common::FsResult;
+use pyo3::prelude::*; 
+
+
+//Define the PythonFilesystem struct
+#[pyclass]
+pub struct PythonFilesystem {
+    inner: LibFilesystem,
+}
+
+//Implement methods for PythonFilesystem
+impl  PythonFilesystem{
+    //New PythonFilesystem 
+    pub fn new(conf: String) -> FsResult<Self>{
+        let fs_conf = FilesystemConf::from_str(conf)?;
+        let cluster_conf = fs_conf.into_cluster_conf()?;
+
+        let inner = LibFilesystem::new(cluster_conf)?;
+        Ok(Self{inner})
+    } 
+
+    //Create file
+    pub fn create(
+        &self, 
+        path: String,
+        overwrite: bool,
+    ) -> FsResult<LibFsWriter>{
+        self.inner.create(path, overwrite)
+    } 
+
+    //Append content
+    pub fn append(&self, path: String) -> FsResult<LibFsWriter>{
+        self.inner.append(path)
+    }
+
+    //Create a directory
+    pub fn mkdir(
+        &self,
+        path: String,
+        create_parent: bool,
+    ) -> FsResult<bool>{
+        self.inner
+            .mkdir(path, create_parent)
+    }
+
+    //Open file
+    pub fn open(&self, path: String) -> FsResult<LibFsReader>{
+        self.inner.open(path)
+    }
+
+    //Get file status
+    pub fn get_file_status(&self, path: String) -> FsResult<BytesMut>{ //之后要考虑这样传递（直接返回所有权）有没有问题
+        let status = self.inner.get_status(path)?;
+        Ok(status)
+
+    }
+
+    //List file system
+    pub fn list_status(&self, path: String) -> FsResult<BytesMut>{
+        let status = self.inner.list_status(path)?;
+        Ok(status)
+    }
+
+    //Rename file
+    pub fn rename(&self, src: String, dst: String) -> FsResult<bool>{
+        self.inner.rename(src,dst)
+    }
+
+    //Delete file
+    pub fn delete(&self, path: String, recursive: bool) -> FsResult<()>{
+        self.inner.delete(path, recursive)
+    }
+
+    //Get master information
+    pub fn get_master_info(&self) -> FsResult<BytesMut>{
+        let status = self.inner.get_master_info()?;
+        Ok(status)
+    }
+}
+
+