refactor(aio): simplify disk_engine interfaces

.gitignore

@@ -29,3 +29,4 @@ thirdparty/src
 thirdparty/output
 
 packages/
+cmake-build-debug/

src/core/aio/disk_engine.cpp

@@ -157,58 +157,6 @@ disk_engine::disk_engine()
     _provider.reset(provider);
 }
 
-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) {
-        return new disk_file(nh);
-    } else {
-        return nullptr;
-    }
-}
-
-error_code disk_engine::close(disk_file *fh)
-{
-    if (nullptr != fh) {
-        auto df = (disk_file *)fh;
-        auto ret = _provider->close(df->native_handle());
-        delete df;
-        return ret;
-    } else {
-        return ERR_INVALID_HANDLE;
-    }
-}
-
-error_code disk_engine::flush(disk_file *fh)
-{
-    if (nullptr != fh) {
-        auto df = (disk_file *)fh;
-        return _provider->flush(df->native_handle());
-    } else {
-        return ERR_INVALID_HANDLE;
-    }
-}
-
-void disk_engine::read(aio_task *aio)
-{
-    if (!aio->spec().on_aio_call.execute(task::get_current_task(), aio, true)) {
-        aio->enqueue(ERR_FILE_OPERATION_FAILED, 0);
-        return;
-    }
-
-    auto dio = aio->get_aio_context();
-    auto df = (disk_file *)dio->file;
-    dio->file = df->native_handle();
-    dio->file_object = df;
-    dio->engine = this;
-    dio->type = AIO_Read;
-
-    auto wk = df->read(aio);
-    if (wk) {
-        return _provider->submit_aio_task(wk);
-    }
-}
-
 class batch_write_io_task : public aio_task
 {
 public:

src/core/aio/disk_engine.h

@@ -70,15 +70,10 @@ class disk_file
 class disk_engine : public utils::singleton<disk_engine>
 {
 public:
-    // asynchronous file read/write
-    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);
 
-    aio_context *prepare_aio_context(aio_task *tsk) { return _provider->prepare_aio_context(tsk); }
     service_node *node() const { return _node; }
+    static aio_provider &provider() { return *instance()._provider.get(); }
 
 private:
     // the object of disk_engine must be created by `singleton::instance`

src/core/aio/file_io.cpp

@@ -33,12 +33,33 @@ namespace file {
 
 /*extern*/ disk_file *open(const char *file_name, int flag, int pmode)
 {
-    return disk_engine::instance().open(file_name, flag, pmode);
+    dsn_handle_t nh = disk_engine::provider().open(file_name, flag, pmode);
+    if (nh != DSN_INVALID_FILE_HANDLE) {
+        return new disk_file(nh);
+    } else {
+        return nullptr;
+    }
 }
 
-/*extern*/ error_code close(disk_file *file) { return disk_engine::instance().close(file); }
+/*extern*/ error_code close(disk_file *file)
+{
+    if (nullptr != file) {
+        auto ret = disk_engine::provider().close(file->native_handle());
+        delete file;
+        return ret;
+    } else {
+        return ERR_INVALID_HANDLE;
+    }
+}
 
-/*extern*/ error_code flush(disk_file *file) { return disk_engine::instance().flush(file); }
+/*extern*/ error_code flush(disk_file *file)
+{
+    if (nullptr != file) {
+        return disk_engine::provider().flush(file->native_handle());
+    } else {
+        return ERR_INVALID_HANDLE;
+    }
+}
 
 /*extern*/ aio_task_ptr read(disk_file *file,
                              char *buffer,
@@ -52,11 +73,20 @@ namespace file {
     auto cb = create_aio_task(callback_code, tracker, std::move(callback), hash);
     cb->get_aio_context()->buffer = buffer;
     cb->get_aio_context()->buffer_size = count;
-    cb->get_aio_context()->file = file;
+    cb->get_aio_context()->file_object = file;
+    cb->get_aio_context()->file = file->native_handle();
     cb->get_aio_context()->file_offset = offset;
     cb->get_aio_context()->type = AIO_Read;
+    cb->get_aio_context()->engine = &disk_engine::instance();
 
-    disk_engine::instance().read(cb);
+    if (!cb->spec().on_aio_call.execute(task::get_current_task(), cb, true)) {
+        cb->enqueue(ERR_FILE_OPERATION_FAILED, 0);
+        return cb;
+    }
+    auto wk = file->read(cb);
+    if (wk) {
+        disk_engine::provider().submit_aio_task(wk);
+    }
     return cb;
 }
 
@@ -104,9 +134,9 @@ namespace file {
     return cb;
 }
 
-aio_context_ptr prepare_aio_context(aio_task *tsk)
+/*extern*/ aio_context_ptr prepare_aio_context(aio_task *tsk)
 {
-    return disk_engine::instance().prepare_aio_context(tsk);
+    return disk_engine::provider().prepare_aio_context(tsk);
 }
 } // namespace file
 } // namespace dsn