Changeset 12765

Timestamp:

Mar 14, 2014, 8:26:33 PM (10 years ago)

Author:

hock@…

Message:

new functionality: SystemQueue::leave() and SystemQueue::join()

( + unit tests)

Files:

• source/ariba/utility/system/SystemQueue.cpp (modified) (4 diffs)
• source/ariba/utility/system/SystemQueue.h (modified) (1 diff)
• tests/SystemQueue-tests.cc (modified) (2 diffs)

source/ariba/utility/system/SystemQueue.cpp

@@ -76 +76 @@
 void SystemQueue::scheduleEvent( const SystemEvent& event, uint32_t delay )
 {
-    assert ( SysQ->running );  // should we really enforce this?
+//     assert ( SysQ->running );  // should we really enforce this?
+    if ( ! SysQ->running )
+    {
+        logging_debug("/// WARNING: The SystemQueue is NOT RUNNING!");
+    }
     
     // copy
@@ -140 +144 @@
     SysQ.reset( new QueueThread() );
 }
+
+
+void SystemQueue::leave()
+{
+    // signal SysQ to quit (and abort queued events)
+    SysQ->cancel();
+}
+
+void SystemQueue::join()
+{
+    if ( sysq_thread )
+    {
+        logging_debug("/// ... joining SysQ thread");
+        sysq_thread->join();
+    }
+}
+
+
 
 void SystemQueue::dropAll( const SystemEventListener* mlistener)
@@ -303 +325 @@
         if ( timedEventsQ.empty() )
         {
-            logging_debug("/// SysQ is going to sleep.");
+//             logging_debug("/// SysQ is going to sleep.");
             
             this->system_queue_idle.wait( lock );
@@ -310 +332 @@
         else
         {
-            logging_debug( "/// SysQ is going to sleep for "
-                        << ( timedEventsQ.top().deadline - get_clock() ).total_milliseconds()
-                        << "ms. Deadline: " 
-                        << timedEventsQ.top().deadline
-                        << ", Clock: "
-                        << get_clock() );
+//             logging_debug( "/// SysQ is going to sleep for "
+//                         << ( timedEventsQ.top().deadline - get_clock() ).total_milliseconds()
+//                         << "ms. Deadline: " 
+//                         << timedEventsQ.top().deadline
+//                         << ", Clock: "
+//                         << get_clock() );
 
             this->system_queue_idle.timed_wait( lock, timedEventsQ.top().deadline );

source/ariba/utility/system/SystemQueue.h

@@ -117 +117 @@
          * Cancels the system queue and ends the processing after the
          * currently processed event is processed.
+     * 
+     * NOTE: Do not call this function from within a SystemQueue-Event.
+     *   Use SystemQueue::leave() instead.
          *
          * This method is thread-safe.
          */
         void cancel();
+    
+    /**
+     * Like SystemQueue::cancel(), but may only be called from within a SystemQueue-Event.
+     * 
+     * NOTE: In this case some cleanup can not be made. -- If the SystemQueue is 
+     *   restarted, SystemQueue::cancel() must be called before SystemQueue::run()
+     *   can be called again.
+     */
+    void leave();
+    
+    /**
+     * Join the SystemQueue thread -- the current thread is blocked until the
+     * SystemQueue finishes.
+     * 
+     * NOTE: Use this only in combination with SystemQueue::leave()
+     * 
+     * [ There is a possible race condition with SystemQueue::cancel(), but 
+     *   SystemQueue::join() should not be used at the same time as 
+     *   SystemQueue::cancel() anyway. (SystemQueue::leave() is fine, though.)
+     */
+    void join();
 
         /**

tests/SystemQueue-tests.cc

@@ -102 +102 @@
         
         checkmark = true;
+    }
+
+    void Leave()
+    {
+        // let's do something before leaving..
+        this->LongRunner();
+        checkmark = false;
+        
+        cout << "### Leaving SysQ ### "<< endl;
+        SystemQueue::instance().leave();
     }
 
@@ -223 +233 @@
 
 /**
+ *  leaves the SystemQueue from inside a scheduled event (in contrast to cancel)
+ * 
+ *  NOTE: due to the SystemQueue singleton design, explicit cleanup is necessary!
+ * 
+ *  [ NOTE: the old System Queue does not support this. ]
+ */
+TEST_F(SystemQueueTest, LeaveFromInsideEvent)
+{
+    SystemQueue& sysq = SystemQueue::instance();
+    
+    // start
+    sysq.run();
+    
+    // scheduleCall
+    sysq.scheduleCall(
+        boost::bind(&SystemQueueTest::Leave, this)
+    );
+
+    // schedule another which must NOT be performed
+    sysq.scheduleCall(
+        boost::bind(&SystemQueueTest::Check, this)
+    );
+    
+    // sleep until the SystemQueue thread has finished
+    sysq.join();
+    
+    EXPECT_FALSE( sysq.isRunning() );
+    
+    // ensure Check() was not perfomed
+    EXPECT_FALSE( sysq.isEmpty() );
+    EXPECT_FALSE( checkmark );
+    
+    // CLEANUP
+    sysq.cancel();
+    
+    EXPECT_FALSE( sysq.isRunning() );
+    EXPECT_TRUE( sysq.isEmpty() );
+}
+
+
+/**
  *  schedule a call and test whether it is actually performed by the SystemQueue
  */