void complete(int r) {
if (should_complete(r)) {
- m_on_finish->complete(filter_return_code(r));
+ r = filter_return_code(r);
+ finish(r);
+ m_on_finish->complete(r);
delete this;
}
}
void async_complete(int r);
virtual bool should_complete(int r) = 0;
- virtual int filter_return_code(int r) {
+ virtual int filter_return_code(int r) const {
return r;
}
+
+ virtual void finish(int r) {
+ }
private:
bool m_canceled;
typename xlist<AsyncRequest<ImageCtxT> *>::item m_xlist_item;
librbd/ObjectMap.cc \
librbd/operation/FlattenRequest.cc \
librbd/operation/RebuildObjectMapRequest.cc \
+ librbd/operation/Request.cc \
librbd/operation/ResizeRequest.cc \
librbd/operation/TrimRequest.cc
noinst_LTLIBRARIES += librbd_internal.la
librbd/WatchNotifyTypes.h \
librbd/operation/FlattenRequest.h \
librbd/operation/RebuildObjectMapRequest.h \
+ librbd/operation/Request.h \
librbd/operation/ResizeRequest.h \
librbd/operation/TrimRequest.h
const uint64_t m_snap_id;
virtual bool should_complete(int r);
- virtual int filter_return_code(int r) {
+ virtual int filter_return_code(int r) const {
// never propagate an error back to the caller
return 0;
}
return false;
}
-void FlattenRequest::send() {
+void FlattenRequest::send_op() {
assert(m_image_ctx.owner_lock.is_locked());
CephContext *cct = m_image_ctx.cct;
ldout(cct, 5) << this << " send" << dendl;
#ifndef CEPH_LIBRBD_OPERATION_FLATTEN_REQUEST_H
#define CEPH_LIBRBD_OPERATION_FLATTEN_REQUEST_H
-#include "librbd/AsyncRequest.h"
+#include "librbd/operation/Request.h"
#include "librbd/parent_types.h"
#include "common/snap_types.h"
namespace operation {
-class FlattenRequest : public AsyncRequest<>
+class FlattenRequest : public Request
{
public:
FlattenRequest(ImageCtx &image_ctx, Context *on_finish,
uint64_t object_size, uint64_t overlap_objects,
const ::SnapContext &snapc, ProgressContext &prog_ctx)
- : AsyncRequest(image_ctx, on_finish), m_object_size(object_size),
+ : Request(image_ctx, on_finish), m_object_size(object_size),
m_overlap_objects(overlap_objects), m_snapc(snapc), m_prog_ctx(prog_ctx),
m_ignore_enoent(false)
{
}
- virtual void send();
-
protected:
+ virtual void send_op();
virtual bool should_complete(int r);
private:
--- /dev/null
+// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
+// vim: ts=8 sw=2 smarttab
+
+#include "librbd/operation/Request.h"
+
+namespace librbd {
+namespace operation {
+
+Request::Request(ImageCtx &image_ctx, Context *on_finish)
+ : AsyncRequest(image_ctx, on_finish) {
+}
+
+void Request::send() {
+ // TODO: record op start in journal
+ send_op();
+}
+
+void Request::finish(int r) {
+ // TODO: record op finish in journal
+}
+
+} // namespace operation
+} // namespace librbd
--- /dev/null
+// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
+// vim: ts=8 sw=2 smarttab
+
+#ifndef CEPH_LIBRBD_OPERATION_REQUEST_H
+#define CEPH_LIBRBD_OPERATION_REQUEST_H
+
+#include "librbd/AsyncRequest.h"
+
+namespace librbd {
+namespace operation {
+
+class Request : public AsyncRequest<> {
+public:
+ Request(ImageCtx &image_ctx, Context *on_finish);
+
+ virtual void send();
+
+protected:
+ virtual void finish(int r);
+ virtual void send_op() = 0;
+
+};
+
+} // namespace operation
+} // namespace librbd
+
+#endif // CEPH_LIBRBD_OPERATION_REQUEST_H
ResizeRequest::ResizeRequest(ImageCtx &image_ctx, Context *on_finish,
uint64_t new_size,
ProgressContext &prog_ctx)
- : AsyncRequest(image_ctx, on_finish),
+ : Request(image_ctx, on_finish),
m_original_size(0), m_new_size(new_size),
m_prog_ctx(prog_ctx), m_new_parent_overlap(0),
m_xlist_item(this)
return false;
}
-void ResizeRequest::send() {
+void ResizeRequest::send_op() {
assert(m_image_ctx.owner_lock.is_locked());
{
#ifndef CEPH_LIBRBD_OPERATION_RESIZE_REQUEST_H
#define CEPH_LIBRBD_OPERATION_RESIZE_REQUEST_H
-#include "librbd/AsyncRequest.h"
+#include "librbd/operation/Request.h"
#include "include/xlist.h"
namespace librbd
namespace operation {
-class ResizeRequest : public AsyncRequest<>
+class ResizeRequest : public Request
{
public:
ResizeRequest(ImageCtx &image_ctx, Context *on_finish, uint64_t new_size,
ProgressContext &prog_ctx);
virtual ~ResizeRequest();
- virtual void send();
-
inline bool shrinking() const {
return m_new_size < m_original_size;
}
return m_new_size;
}
+protected:
+ virtual void send_op();
+ virtual bool should_complete(int r);
+
private:
/**
* Resize goes through the following state machine to resize the image
xlist<ResizeRequest *>::item m_xlist_item;
- virtual bool should_complete(int r);
-
void send_flush();
void send_invalidate_cache();
void send_trim_image();
case STATE_CLEAN_BOUNDARY:
ldout(cct, 5) << "CLEAN_BOUNDARY" << dendl;
- finish(0);
+ send_finish(0);
break;
case STATE_FINISHED:
assert(m_image_ctx.owner_lock.is_locked());
CephContext *cct = m_image_ctx.cct;
if (m_delete_off <= m_new_size) {
- finish(0);
+ send_finish(0);
return;
}
completion->finish_adding_requests();
}
-void TrimRequest::finish(int r) {
+void TrimRequest::send_finish(int r) {
m_state = STATE_FINISHED;
async_complete(r);
}
void send_pre_remove();
void send_post_remove();
void send_clean_boundary();
- void finish(int r);
+ void send_finish(int r);
};
} // namespace operation