NSR: nsr client code generation patch

This version of the client checks if the error returned
is EREMOTE or ENOTCONN, and if not unwnds the error back

In case of a EREMOTE or ENOTCONN error, it retries on
all the bricks in the replica subgroup, and if the error
still persists, it waits for a sec before going through the
same exercise again.

Change-Id: I916bed32f0820f381dd60fdde3d05b71c69a34dc
Signed-off-by: Avra Sengupta <asengupt@redhat.com>
Reviewed-on: http://review.gluster.org/12388
Smoke: Gluster Build System <jenkins@build.gluster.com>
Reviewed-by: Jeff Darcy <jdarcy@redhat.com>
NetBSD-regression: NetBSD Build System <jenkins@build.gluster.org>
CentOS-regression: Gluster Build System <jenkins@build.gluster.com>

1 files changed, 113 insertions, 0 deletions

diff --git a/xlators/experimental/nsr-client/src/fop-template.c b/xlators/experimental/nsr-client/src/fop-template.c
new file mode 100644
index 00000000000..59708732aa0
--- /dev/null
+++ b/xlators/experimental/nsr-client/src/fop-template.c
@@ -0,0 +1,113 @@
+/* template-name fop */
+int32_t
+nsrc_@NAME@ (call_frame_t *frame, xlator_t *this,
+             @LONG_ARGS@)
+{
+        nsrc_local_t    *local          = NULL;
+        xlator_t        *target_xl      = ACTIVE_CHILD(this);
+
+        local = mem_get(this->local_pool);
+        if (!local) {
+                goto err;
+        }
+
+        local->stub = fop_@NAME@_stub (frame, nsrc_@NAME@_continue,
+                                       @SHORT_ARGS@);
+        if (!local->stub) {
+                goto err;
+        }
+        local->curr_xl = target_xl;
+        local->scars = 0;
+
+        frame->local = local;
+        STACK_WIND_COOKIE (frame, nsrc_@NAME@_cbk, target_xl,
+                    target_xl, target_xl->fops->@NAME@,
+                    @SHORT_ARGS@);
+        return 0;
+
+err:
+        if (local) {
+                mem_put(local);
+        }
+        STACK_UNWIND_STRICT (@NAME@, frame, -1, ENOMEM,
+                             @ERROR_ARGS@);
+        return 0;
+}
+
+/* template-name cbk */
+int32_t
+nsrc_@NAME@_cbk (call_frame_t *frame, void *cookie, xlator_t *this,
+                 int32_t op_ret, int32_t op_errno,
+                 @LONG_ARGS@)
+{
+        nsrc_local_t    *local          = frame->local;
+        xlator_t        *last_xl        = cookie;
+        xlator_t        *next_xl;
+        nsrc_private_t  *priv           = this->private;
+        struct timespec spec;
+
+        if (op_ret != (-1)) {
+                if (local->scars) {
+                        gf_msg (this->name, GF_LOG_INFO, 0, N_MSG_RETRY_MSG,
+                                HILITE("retried %p OK"), frame->local);
+                }
+                priv->active = last_xl;
+                goto unwind;
+        }
+        if ((op_errno != EREMOTE) && (op_errno != ENOTCONN)) {
+                goto unwind;
+        }
+
+        /* TBD: get leader ID from xdata? */
+        next_xl = next_xlator(this, last_xl);
+        /*
+         * We can't just give up after we've tried all bricks, because it's
+         * quite likely that a new leader election just hasn't finished yet.
+         * We also shouldn't retry endlessly, and especially not at a high
+         * rate, but that's good enough while we work on other things.
+         *
+         * TBD: implement slow/finite retry via a worker thread
+         */
+        if (!next_xl || (local->scars >= SCAR_LIMIT)) {
+                gf_msg (this->name, GF_LOG_DEBUG, 0, N_MSG_RETRY_MSG,
+                        HILITE("ran out of retries for %p"), frame->local);
+                goto unwind;
+        }
+
+        local->curr_xl = next_xl;
+        local->scars += 1;
+        spec.tv_sec = 1;
+        spec.tv_nsec = 0;
+        /*
+         * WARNING
+         *
+         * Just calling gf_timer_call_after like this leaves open the
+         * possibility that writes will get reordered, if a first write is
+         * rescheduled and then a second comes along to find an updated
+         * priv->active before the first actually executes.  We might need to
+         * implement a stricter (and more complicated) queuing mechanism to
+         * ensure absolute consistency in this case.
+         */
+        if (gf_timer_call_after(this->ctx, spec, nsrc_retry_cb, local)) {
+                return 0;
+        }
+
+unwind:
+        call_stub_destroy(local->stub);
+        STACK_UNWIND_STRICT (@NAME@, frame, op_ret, op_errno,
+                                     @SHORT_ARGS@);
+        return 0;
+}
+
+/* template-name cont-func */
+int32_t
+nsrc_@NAME@_continue (call_frame_t *frame, xlator_t *this,
+                      @LONG_ARGS@)
+{
+        nsrc_local_t    *local  = frame->local;
+
+        STACK_WIND_COOKIE (frame, nsrc_@NAME@_cbk, local->curr_xl,
+                           local->curr_xl, local->curr_xl->fops->@NAME@,
+                           @SHORT_ARGS@);
+        return 0;
+}