mon/PaxosService: move classes to cc file

Signed-off-by: Michal Jarzabek <stiopa@gmail.com>

diff --git a/src/mon/PaxosService.cc b/src/mon/PaxosService.cc
index 647309deec044b500693f9b2df0a786d94490bf7..9b7fc58d05e8503f073b58ffd4e26da468c3a8e9 100644 (file)
--- a/src/mon/PaxosService.cc
+++ b/src/mon/PaxosService.cc
@@ -96,6 +96,25 @@ bool PaxosService::dispatch(MonOpRequestRef op)
       } else {
        // delay a bit
        if (!proposal_timer) {
+         /**
+          * Callback class used to propose the pending value once the proposal_timer
+          * fires up.
+          */
+         class C_Propose : public Context {
+           PaxosService *ps;
+         public:
+           explicit C_Propose(PaxosService *p) : ps(p) { }
+           void finish(int r) {
+             ps->proposal_timer = 0;
+             if (r >= 0)
+               ps->propose_pending();
+             else if (r == -ECANCELED || r == -EAGAIN)
+               return;
+             else
+               assert(0 == "bad return value for C_Propose");
+           }
+         };
+
          proposal_timer = new C_Propose(this);
          dout(10) << " setting proposal_timer " << proposal_timer << " with delay of " << delay << dendl;
          mon->timer.add_event_after(delay, proposal_timer);
@@ -193,6 +212,30 @@ void PaxosService::propose_pending()
 
   // apply to paxos
   proposing = true;
+  /**
+   * Callback class used to mark us as active once a proposal finishes going
+   * through Paxos.
+   *
+   * We should wake people up *only* *after* we inform the service we
+   * just went active. And we should wake people up only once we finish
+   * going active. This is why we first go active, avoiding to wake up the
+   * wrong people at the wrong time, such as waking up a C_RetryMessage
+   * before waking up a C_Active, thus ending up without a pending value.
+   */
+  class C_Committed : public Context {
+    PaxosService *ps;
+  public:
+    explicit C_Committed(PaxosService *p) : ps(p) { }
+    void finish(int r) {
+      ps->proposing = false;
+      if (r >= 0)
+       ps->_active();
+      else if (r == -ECANCELED || r == -EAGAIN)
+       return;
+      else
+       assert(0 == "bad return value for C_Committed");
+    }
+  };
   paxos->queue_pending_finisher(new C_Committed(this));
   paxos->trigger_propose();
 }
@@ -248,6 +291,23 @@ void PaxosService::_active()
   }
   if (!is_active()) {
     dout(10) << "_active - not active" << dendl;
+    /**
+     * Callback used to make sure we call the PaxosService::_active function
+     * whenever a condition is fulfilled.
+     *
+     * This is used in multiple situations, from waiting for the Paxos to commit
+     * our proposed value, to waiting for the Paxos to become active once an
+     * election is finished.
+     */
+    class C_Active : public Context {
+      PaxosService *svc;
+    public:
+      explicit C_Active(PaxosService *s) : svc(s) {}
+      void finish(int r) {
+       if (r >= 0)
+         svc->_active();
+      }
+    };
     wait_for_active_ctx(new C_Active(this));
     return;
   }

diff --git a/src/mon/PaxosService.h b/src/mon/PaxosService.h
index 4f74e0cbe5c5649dac28ca5029bcbbad71bd6e57..bb550d1ca07302cba3dc62a891e6037a86dd5265 100644 (file)
--- a/src/mon/PaxosService.h
+++ b/src/mon/PaxosService.h
@@ -114,67 +114,6 @@ protected:
     }
   };
 
-  /**
-   * Callback used to make sure we call the PaxosService::_active function
-   * whenever a condition is fulfilled.
-   *
-   * This is used in multiple situations, from waiting for the Paxos to commit
-   * our proposed value, to waiting for the Paxos to become active once an
-   * election is finished.
-   */
-  class C_Active : public Context {
-    PaxosService *svc;
-  public:
-    explicit C_Active(PaxosService *s) : svc(s) {}
-    void finish(int r) {
-      if (r >= 0)
-       svc->_active();
-    }
-  };
-
-  /**
-   * Callback class used to propose the pending value once the proposal_timer
-   * fires up.
-   */
-  class C_Propose : public Context {
-    PaxosService *ps;
-  public:
-    explicit C_Propose(PaxosService *p) : ps(p) { }
-    void finish(int r) {
-      ps->proposal_timer = 0;
-      if (r >= 0)
-       ps->propose_pending();
-      else if (r == -ECANCELED || r == -EAGAIN)
-       return;
-      else
-       assert(0 == "bad return value for C_Propose");
-    }
-  };
-
-  /**
-   * Callback class used to mark us as active once a proposal finishes going
-   * through Paxos.
-   *
-   * We should wake people up *only* *after* we inform the service we
-   * just went active. And we should wake people up only once we finish
-   * going active. This is why we first go active, avoiding to wake up the
-   * wrong people at the wrong time, such as waking up a C_RetryMessage
-   * before waking up a C_Active, thus ending up without a pending value.
-   */
-  class C_Committed : public Context {
-    PaxosService *ps;
-  public:
-    explicit C_Committed(PaxosService *p) : ps(p) { }
-    void finish(int r) {
-      ps->proposing = false;
-      if (r >= 0)
-       ps->_active();
-      else if (r == -ECANCELED || r == -EAGAIN)
-       return;
-      else
-       assert(0 == "bad return value for C_Committed");
-    }
-  };
   /**
    * @}
    */