Changed directory monitor to polling behaviour :(

3 files changed, 128 insertions, 86 deletions

diff --git a/src/uscxml/plugins/element/postpone/PostponeElement.cpp b/src/uscxml/plugins/element/postpone/PostponeElement.cpp
index 5dc1c60..b50b5c2 100644
--- a/src/uscxml/plugins/element/postpone/PostponeElement.cpp
+++ b/src/uscxml/plugins/element/postpone/PostponeElement.cpp
@@ -41,16 +41,16 @@ void PostponeElement::enterElement(const Arabica::DOM::Node<std::string>& node)
 	}
 
 	// when will we refire the event?
-  std::string until;
-  try {
-    if (HAS_ATTR(node, "untilexpr")) {
-      until = _interpreter->getDataModel().evalAsString(ATTR(node, "untilexpr"));
-    } else if (HAS_ATTR(node, "until")) {
-      until = ATTR(node, "until");
-    }
+	std::string until;
+	try {
+		if (HAS_ATTR(node, "untilexpr")) {
+			until = _interpreter->getDataModel().evalAsString(ATTR(node, "untilexpr"));
+		} else if (HAS_ATTR(node, "until")) {
+			until = ATTR(node, "until");
+		}
 	} catch (Event e) {
 		LOG(ERROR) << "Syntax error in postpone element untilexpr:" << std::endl << e << std::endl;
-    return;
+		return;
 	}
 
 	if (until.length() == 0) {
@@ -58,30 +58,65 @@ void PostponeElement::enterElement(const Arabica::DOM::Node<std::string>& node)
 		return;
 	}
 
+	LOG(INFO) << until;
+
+#if 0
+	std::string timeoutStr = "0s";
+	try {
+		if (HAS_ATTR(node, "timeoutexpr")) {
+			timeoutStr = _interpreter->getDataModel().evalAsString(ATTR(node, "timeoutexpr"));
+		} else if (HAS_ATTR(node, "timeout")) {
+			timeoutStr = ATTR(node, "timeout");
+		}
+	} catch (Event e) {
+		LOG(ERROR) << "Syntax error in postpone element timeoutexpr:" << std::endl << e << std::endl;
+		return;
+	}
+
+	uint64_t timeout = 0;
+	NumAttr timeoutAttr(timeoutStr);
+	if (boost::iequals(timeoutAttr.unit, "s")) {
+		timeout = strTo<int>(timeoutAttr.value) * 1000;
+	} else if (boost::iequals(timeoutAttr.unit, "ms")) {
+		timeout = strTo<int>(timeoutAttr.value);
+	}
+	if (timeout > 0) {
+		timeout += tthread::chrono::system_clock::now();
+	}
+#endif
 	Event currEvent = _interpreter->getCurrentEvent();
-	Resubmitter::postpone(currEvent, until, _interpreter);
+	Resubmitter::postpone(currEvent, until, 0, _interpreter);
 }
 
 void PostponeElement::exitElement(const Arabica::DOM::Node<std::string>& node) {
 }
 
-void PostponeElement::Resubmitter::postpone(const Event& event, std::string until, Interpreter* interpreter) {
+void PostponeElement::Resubmitter::postpone(const Event& event, std::string until, uint64_t timeout, Interpreter* interpreter) {
 	Resubmitter* resubmitter = getInstance(interpreter);
-	resubmitter->_postponedEvents.push_back(std::make_pair(until, event));
+	resubmitter->_postponedEvents.push_back(Postponed(event, until, timeout));
 }
 
 void PostponeElement::Resubmitter::onStableConfiguration(Interpreter* interpreter) {
-	std::list<std::pair<std::string, Event> >::iterator eventIter = _postponedEvents.begin();
+	std::list<Postponed>::iterator eventIter = _postponedEvents.begin();
 	while(eventIter != _postponedEvents.end()) {
 		try {
-      LOG(INFO) << "Reevaluating: >> " << eventIter->first << " <<";
-			if (interpreter->getDataModel().evalAsBool(eventIter->first)) {
-        LOG(INFO) << "  -> is TRUE";
-				interpreter->receive(eventIter->second, true);
+//      LOG(INFO) << "Reevaluating: >> " << eventIter->first << " <<";
+			if (eventIter->timeout > 0 && tthread::chrono::system_clock::now() < eventIter->timeout) {
+				// TODO: We should use an event queue
+//        LOG(INFO) << "  -> Timeout";
+				eventIter->event.name += ".timeout";
+				interpreter->receive(eventIter->event, true);
+				_postponedEvents.erase(eventIter);
+				break;
+			}
+			if (interpreter->getDataModel().evalAsBool(eventIter->until)) {
+//        LOG(INFO) << "  -> is TRUE";
+				eventIter->event.name += ".postponed";
+				interpreter->receive(eventIter->event, true);
 				_postponedEvents.erase(eventIter);
 				break;
 			}
-      LOG(INFO) << "  -> is FALSE";
+//      LOG(INFO) << "  -> is FALSE";
 		} catch (Event e) {
 			LOG(ERROR) << "Syntax error while evaluating until attribute of postpone element:" << std::endl << e << std::endl;
 			_postponedEvents.erase(eventIter++);
diff --git a/src/uscxml/plugins/element/postpone/PostponeElement.h b/src/uscxml/plugins/element/postpone/PostponeElement.h
index 03aafde..eb7a738 100644
--- a/src/uscxml/plugins/element/postpone/PostponeElement.h
+++ b/src/uscxml/plugins/element/postpone/PostponeElement.h
@@ -12,6 +12,14 @@ namespace uscxml {
 
 class PostponeElement : public ExecutableContentImpl {
 public:
+	struct Postponed {
+		Postponed(const Event& event, const std::string& until, long timeout) :
+			event(event), until(until), timeout(timeout) {}
+		Event event;
+		std::string until;
+		uint64_t timeout;
+	};
+
 	PostponeElement() {}
 	virtual ~PostponeElement() {}
 	boost::shared_ptr<ExecutableContentImpl> create(Interpreter* interpreter);
@@ -40,13 +48,13 @@ protected:
 		}
 
 		static Resubmitter* getInstance(Interpreter* interpreter);
-		static void postpone(const Event& event, std::string until, Interpreter* interpreter);
+		static void postpone(const Event& event, std::string until, uint64_t timeout, Interpreter* interpreter);
 
 		// InterpreterMonitor
 		void onStableConfiguration(Interpreter* interpreter);
 		void afterCompletion(Interpreter* interpreter);
 
-		std::list<std::pair<std::string, Event> > _postponedEvents;
+		std::list<Postponed> _postponedEvents;
 		static std::map<Interpreter*, Resubmitter*> _instances;
 		static tthread::recursive_mutex _accessLock;
 
diff --git a/src/uscxml/plugins/element/response/ResponseElement.cpp b/src/uscxml/plugins/element/response/ResponseElement.cpp
index 62ebf34..2e25b27 100644
--- a/src/uscxml/plugins/element/response/ResponseElement.cpp
+++ b/src/uscxml/plugins/element/response/ResponseElement.cpp
@@ -52,7 +52,7 @@ void ResponseElement::enterElement(const Arabica::DOM::Node<std::string>& node)
 		return;
 	}
 	httpReply.status = strTo<int>(statusStr);;
-  
+
 	// extract the content
 	Arabica::XPath::NodeSet<std::string> contents = Interpreter::filterChildElements(_interpreter->getXMLPrefixForNS(getNamespace()) + "content", node);
 	if (contents.size() > 0) {
@@ -63,91 +63,90 @@ void ResponseElement::enterElement(const Arabica::DOM::Node<std::string>& node)
 					httpReply.content = contentValue;
 				} catch (Event e) {
 					LOG(ERROR) << "Syntax error with expr in content child of response element:" << std::endl << e << std::endl;
-          return;
+					return;
 				}
 			} else {
 				LOG(ERROR) << "content element has expr attribute but no datamodel is specified.";
-        return;
+				return;
 			}
 		} else if (HAS_ATTR(contents[0], "file") || HAS_ATTR(contents[0], "fileexpr")) { // -- content is from file ------
-      URL file;
+			URL file;
 			if (HAS_ATTR(contents[0], "fileexpr")) {
-        if (_interpreter->getDataModel()) {
-          try {
-            file = "file://" + _interpreter->getDataModel().evalAsString(ATTR(contents[0], "fileexpr"));
-          } catch (Event e) {
-            LOG(ERROR) << "Syntax error with fileexpr in content child of response element:" << std::endl << e << std::endl;
-            return;
-          }
+				if (_interpreter->getDataModel()) {
+					try {
+						file = "file://" + _interpreter->getDataModel().evalAsString(ATTR(contents[0], "fileexpr"));
+					} catch (Event e) {
+						LOG(ERROR) << "Syntax error with fileexpr in content child of response element:" << std::endl << e << std::endl;
+						return;
+					}
 				}
 			} else {
-        file = "file://" + ATTR(contents[0], "fileexpr");
+				file = "file://" + ATTR(contents[0], "fileexpr");
+			}
+			if (file) {
+				httpReply.content = file.getInContent();
+				size_t lastDot;
+				if ((lastDot = file.path().find_last_of(".")) != std::string::npos) {
+					std::string extension = file.path().substr(lastDot + 1);
+					std::string mimeType = HTTPServer::mimeTypeForExtension(extension);
+					if (mimeType.length() > 0) {
+						httpReply.headers["Content-Type"] = mimeType;
+					}
+				}
 			}
-      if (file) {
-        httpReply.content = file.getInContent();
-        size_t lastDot;
-        if ((lastDot = file.path().find_last_of(".")) != std::string::npos) {
-          std::string extension = file.path().substr(lastDot + 1);
-          std::string mimeType = HTTPServer::mimeTypeForExtension(extension);
-          if (mimeType.length() > 0) {
-            httpReply.headers["Content-Type"] = mimeType;
-          }
-        }
-      }
 		} else if (contents[0].hasChildNodes()) {  // -- content embedded as child nodes ------
 			httpReply.content = contents[0].getFirstChild().getNodeValue();
 		} else {
 			LOG(ERROR) << "content element does not specify any content.";
-      return;
+			return;
 		}
 	}
 
-  // process headers
+	// process headers
 	Arabica::XPath::NodeSet<std::string> headers = Interpreter::filterChildElements(_interpreter->getXMLPrefixForNS(getNamespace()) + "header", node);
-  for (int i = 0; i < headers.size(); i++) {
-    std::string name;
-    if (HAS_ATTR(headers[i], "name")) {
-      name = ATTR(headers[i], "name");
-    } else if(HAS_ATTR(headers[i], "nameexpr")) {
-      if (_interpreter->getDataModel()) {
-        try {
-          name = _interpreter->getDataModel().evalAsString(ATTR(headers[i], "nameexpr"));
-        } catch (Event e) {
-          LOG(ERROR) << "Syntax error with nameexpr in header child of response element:" << std::endl << e << std::endl;
-          return;
-        }
-      } else {
+	for (int i = 0; i < headers.size(); i++) {
+		std::string name;
+		if (HAS_ATTR(headers[i], "name")) {
+			name = ATTR(headers[i], "name");
+		} else if(HAS_ATTR(headers[i], "nameexpr")) {
+			if (_interpreter->getDataModel()) {
+				try {
+					name = _interpreter->getDataModel().evalAsString(ATTR(headers[i], "nameexpr"));
+				} catch (Event e) {
+					LOG(ERROR) << "Syntax error with nameexpr in header child of response element:" << std::endl << e << std::endl;
+					return;
+				}
+			} else {
 				LOG(ERROR) << "header element has nameexpr attribute but no datamodel is specified.";
-        return;
-      }
-    } else {
-      LOG(ERROR) << "header element has no name or nameexpr attribute.";
-      return;
-    }
-
-    std::string value;
-    if (HAS_ATTR(headers[i], "value")) {
-      value = ATTR(headers[i], "value");
-    } else if(HAS_ATTR(headers[i], "expr")) {
-      if (_interpreter->getDataModel()) {
-        try {
-          value = _interpreter->getDataModel().evalAsString(ATTR(headers[i], "expr"));
-        } catch (Event e) {
-          LOG(ERROR) << "Syntax error with expr in header child of response element:" << std::endl << e << std::endl;
-          return;
-        }
-      } else {
+				return;
+			}
+		} else {
+			LOG(ERROR) << "header element has no name or nameexpr attribute.";
+			return;
+		}
+
+		std::string value;
+		if (HAS_ATTR(headers[i], "value")) {
+			value = ATTR(headers[i], "value");
+		} else if(HAS_ATTR(headers[i], "expr")) {
+			if (_interpreter->getDataModel()) {
+				try {
+					value = _interpreter->getDataModel().evalAsString(ATTR(headers[i], "expr"));
+				} catch (Event e) {
+					LOG(ERROR) << "Syntax error with expr in header child of response element:" << std::endl << e << std::endl;
+					return;
+				}
+			} else {
 				LOG(ERROR) << "header element has expr attribute but no datamodel is specified.";
-        return;
-      }
-    } else {
-      LOG(ERROR) << "header element has no value or expr attribute.";
-      return;
-    }
-
-    httpReply.headers[name] = value;
-  }
-  
+				return;
+			}
+		} else {
+			LOG(ERROR) << "header element has no value or expr attribute.";
+			return;
+		}
+
+		httpReply.headers[name] = value;
+	}
 
 	// send the reply
 	HTTPServer::reply(httpReply);