*: expose disk_file that was hidden under dsn_handle_t

include/dsn/c/api_layer1.h

@@ -276,63 +276,6 @@ typedef struct
     int size;
 } dsn_file_buffer_t;
 
-/*!
- open file
-
- \param file_name filename of the file.
- \param flag      flags such as O_RDONLY | O_BINARY used by ::open
- \param pmode     permission mode used by ::open
-
- \return file handle
- */
-extern DSN_API dsn_handle_t dsn_file_open(const char *file_name, int flag, int pmode);
-
-/*! close the file handle */
-extern DSN_API dsn::error_code dsn_file_close(dsn_handle_t file);
-
-/*! flush the buffer of the given file */
-extern DSN_API dsn::error_code dsn_file_flush(dsn_handle_t file);
-
-/*!
- read file asynchronously
-
- \param file   file handle
- \param buffer read buffer
- \param count  byte size of the read buffer
- \param offset offset in the file to start reading
- \param cb     callback aio task to be executed on completion
- */
-extern DSN_API void
-dsn_file_read(dsn_handle_t file, char *buffer, int count, uint64_t offset, dsn::aio_task *cb);
-
-/*!
- write file asynchronously
-
- \param file   file handle
- \param buffer write buffer
- \param count  byte size of the to-be-written content
- \param offset offset in the file to start write
- \param cb     callback aio task to be executed on completion
- */
-extern DSN_API void dsn_file_write(
-    dsn_handle_t file, const char *buffer, int count, uint64_t offset, dsn::aio_task *cb);
-
-/*!
- write file asynchronously with vector buffers
-
- \param file          file handle
- \param buffers       write buffers
- \param buffer_count  number of write buffers
- \param offset        offset in the file to start write
- \param cb            callback aio task to be executed on completion
- */
-extern DSN_API void dsn_file_write_vector(dsn_handle_t file,
-                                          const dsn_file_buffer_t *buffers,
-                                          int buffer_count,
-                                          uint64_t offset,
-                                          dsn::aio_task *cb);
-/*@}*/
-
 /*!
 @defgroup env Environment
 

include/dsn/tool-api/aio_provider.h

@@ -75,7 +75,9 @@ class aio_provider
     DSN_API service_node *node() const;
 
     // return DSN_INVALID_FILE_HANDLE if failed
+    // TODO(wutao1): return uint64_t instead (because we only support linux now)
     virtual dsn_handle_t open(const char *file_name, int flag, int pmode) = 0;
+
     virtual error_code close(dsn_handle_t fh) = 0;
     virtual error_code flush(dsn_handle_t fh) = 0;
     virtual void aio(aio_task *aio) = 0;

include/dsn/tool-api/async_calls.h

@@ -28,7 +28,7 @@
 
 #include <dsn/service_api_c.h>
 #include <dsn/utility/function_traits.h>
-#include <dsn/tool-api/task.h>
+#include <dsn/tool-api/file_io.h>
 #include <dsn/tool-api/task_tracker.h>
 #include <dsn/cpp/serialization.h>
 
@@ -236,7 +236,7 @@ create_aio_task(task_code code, task_tracker *tracker, aio_handler &&callback, i
     return t;
 }
 
-inline aio_task_ptr read(dsn_handle_t fh,
+inline aio_task_ptr read(disk_file *fh,
                          char *buffer,
                          int count,
                          uint64_t offset,
@@ -250,7 +250,7 @@ inline aio_task_ptr read(dsn_handle_t fh,
     return tsk;
 }
 
-inline aio_task_ptr write(dsn_handle_t fh,
+inline aio_task_ptr write(disk_file *fh,
                           const char *buffer,
                           int count,
                           uint64_t offset,
@@ -264,7 +264,7 @@ inline aio_task_ptr write(dsn_handle_t fh,
     return tsk;
 }
 
-inline aio_task_ptr write_vector(dsn_handle_t fh,
+inline aio_task_ptr write_vector(disk_file *fh,
                                  const dsn_file_buffer_t *buffers,
                                  int buffer_count,
                                  uint64_t offset,

include/dsn/tool-api/file_io.h

@@ -0,0 +1,91 @@
+/*
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2015 Microsoft Corporation
+ *
+ * -=- Robust Distributed System Nucleus (rDSN) -=-
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#pragma once
+
+#include <dsn/tool-api/task.h>
+
+namespace dsn {
+
+// forward declaration
+class disk_file;
+
+/*!
+ open file
+
+ \param file_name filename of the file.
+ \param flag      flags such as O_RDONLY | O_BINARY used by ::open
+ \param pmode     permission mode used by ::open
+
+ \return file handle
+ */
+extern disk_file *dsn_file_open(const char *file_name, int flag, int pmode);
+
+/*! close the file handle */
+extern error_code dsn_file_close(disk_file *file);
+
+/*! flush the buffer of the given file */
+extern error_code dsn_file_flush(disk_file *file);
+
+/*!
+ read file asynchronously
+
+ \param file   file handle
+ \param buffer read buffer
+ \param count  byte size of the read buffer
+ \param offset offset in the file to start reading
+ \param cb     callback aio task to be executed on completion
+ */
+extern void dsn_file_read(disk_file *file, char *buffer, int count, uint64_t offset, aio_task *cb);
+
+/*!
+ write file asynchronously
+
+ \param file   file handle
+ \param buffer write buffer
+ \param count  byte size of the to-be-written content
+ \param offset offset in the file to start write
+ \param cb     callback aio task to be executed on completion
+ */
+extern void
+dsn_file_write(disk_file *file, const char *buffer, int count, uint64_t offset, aio_task *cb);
+
+/*!
+ write file asynchronously with vector buffers
+
+ \param file          file handle
+ \param buffers       write buffers
+ \param buffer_count  number of write buffers
+ \param offset        offset in the file to start write
+ \param cb            callback aio task to be executed on completion
+ */
+extern void dsn_file_write_vector(disk_file *file,
+                                  const dsn_file_buffer_t *buffers,
+                                  int buffer_count,
+                                  uint64_t offset,
+                                  aio_task *cb);
+
+} // namespace dsn

src/core/core/disk_engine.cpp

@@ -151,7 +151,7 @@ void disk_engine::start(aio_provider *provider)
     _is_running = true;
 }
 
-dsn_handle_t disk_engine::open(const char *file_name, int flag, int pmode)
+disk_file *disk_engine::open(const char *file_name, int flag, int pmode)
 {
     dsn_handle_t nh = _provider->open(file_name, flag, pmode);
     if (nh != DSN_INVALID_FILE_HANDLE) {
@@ -161,7 +161,7 @@ dsn_handle_t disk_engine::open(const char *file_name, int flag, int pmode)
     }
 }
 
-error_code disk_engine::close(dsn_handle_t fh)
+error_code disk_engine::close(disk_file *fh)
 {
     if (nullptr != fh) {
         auto df = (disk_file *)fh;
@@ -173,7 +173,7 @@ error_code disk_engine::close(dsn_handle_t fh)
     }
 }
 
-error_code disk_engine::flush(dsn_handle_t fh)
+error_code disk_engine::flush(disk_file *fh)
 {
     if (nullptr != fh) {
         auto df = (disk_file *)fh;

src/core/core/disk_engine.h

@@ -59,6 +59,7 @@ class disk_file
     aio_task *on_read_completed(aio_task *wk, error_code err, size_t size);
     aio_task *on_write_completed(aio_task *wk, void *ctx, error_code err, size_t size);
 
+    // TODO(wutao1): make it uint64_t
     dsn_handle_t native_handle() const { return _handle; }
 
 private:
@@ -76,9 +77,9 @@ class disk_engine
     void start(aio_provider *provider);
 
     // asynchonous file read/write
-    dsn_handle_t open(const char *file_name, int flag, int pmode);
-    error_code close(dsn_handle_t fh);
-    error_code flush(dsn_handle_t fh);
+    disk_file *open(const char *file_name, int flag, int pmode);
+    error_code close(disk_file *fh);
+    error_code flush(disk_file *fh);
     void read(aio_task *aio);
     void write(aio_task *aio);
 

src/core/core/file_io.cpp

@@ -0,0 +1,96 @@
+/*
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2015 Microsoft Corporation
+ *
+ * -=- Robust Distributed System Nucleus (rDSN) -=-
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include <dsn/tool-api/file_io.h>
+
+#include "disk_engine.h"
+
+namespace dsn {
+
+/*extern*/ disk_file *dsn_file_open(const char *file_name, int flag, int pmode)
+{
+    return task::get_current_disk()->open(file_name, flag, pmode);
+}
+
+/*extern*/ error_code dsn_file_close(disk_file *file)
+{
+    return task::get_current_disk()->close(file);
+}
+
+/*extern*/ error_code dsn_file_flush(disk_file *file)
+{
+    return task::get_current_disk()->flush(file);
+}
+
+/*extern*/ void
+dsn_file_read(disk_file *file, char *buffer, int count, uint64_t offset, aio_task *cb)
+{
+    cb->aio()->buffer = buffer;
+    cb->aio()->buffer_size = count;
+    cb->aio()->engine = nullptr;
+    cb->aio()->file = file;
+    cb->aio()->file_offset = offset;
+    cb->aio()->type = AIO_Read;
+
+    task::get_current_disk()->read(cb);
+}
+
+/*extern*/ void
+dsn_file_write(disk_file *file, const char *buffer, int count, uint64_t offset, aio_task *cb)
+{
+    cb->aio()->buffer = (char *)buffer;
+    cb->aio()->buffer_size = count;
+    cb->aio()->engine = nullptr;
+    cb->aio()->file = file;
+    cb->aio()->file_offset = offset;
+    cb->aio()->type = AIO_Write;
+
+    task::get_current_disk()->write(cb);
+}
+
+/*extern*/ void dsn_file_write_vector(disk_file *file,
+                                      const dsn_file_buffer_t *buffers,
+                                      int buffer_count,
+                                      uint64_t offset,
+                                      aio_task *cb)
+{
+    cb->aio()->buffer = nullptr;
+    cb->aio()->buffer_size = 0;
+    cb->aio()->engine = nullptr;
+    cb->aio()->file = file;
+    cb->aio()->file_offset = offset;
+    cb->aio()->type = AIO_Write;
+    for (int i = 0; i < buffer_count; i++) {
+        if (buffers[i].size > 0) {
+            cb->_unmerged_write_buffers.push_back(buffers[i]);
+            cb->aio()->buffer_size += buffers[i].size;
+        }
+    }
+
+    task::get_current_disk()->write(cb);
+}
+
+} // namespace dsn