Merge pull request #1255 from fledge-iot/2.3.0RC

2.3.0RC

C/common/config_category.cpp

@@ -476,6 +476,8 @@ string ConfigCategory::getItemAttribute(const string& itemName,
  return m_items[i]->m_deprecated;
  case RULE_ATTR:
  return m_items[i]->m_rule;
+ case BUCKET_PROPERTIES_ATTR:
+ return m_items[i]->m_bucketProperties;
  default:
  throw new ConfigItemAttributeNotFound();
  }
@@ -541,6 +543,9 @@ bool ConfigCategory::setItemAttribute(const string& itemName,
  case RULE_ATTR:
  m_items[i]->m_rule = value;
  return true;
+ case BUCKET_PROPERTIES_ATTR:
+ m_items[i]->m_bucketProperties = value;
+ return true;
  default:
  return false;
  }
@@ -1038,6 +1043,10 @@ ConfigCategory::CategoryItem::CategoryItem(const string& name,
  {
  m_itemType = CodeItem;
  }
+ if (m_type.compare("bucket") == 0)
+ {
+ m_itemType = BucketItem;
+ }
 
  if (item.HasMember("deprecated"))
  {
@@ -1083,6 +1092,33 @@ ConfigCategory::CategoryItem::CategoryItem(const string& name,
  m_rule = "";
  }
 
+ if (item.HasMember("properties"))
+ {
+ Logger::getLogger()->debug("item['properties'].IsString()=%s, item['properties'].IsObject()=%s", 
+ item["properties"].IsString()?"true":"false",
+ item["properties"].IsObject()?"true":"false");
+
+ rapidjson::StringBuffer strbuf;
+ rapidjson::Writer<rapidjson::StringBuffer> writer(strbuf);
+ item["properties"].Accept(writer);
+ m_bucketProperties = item["properties"].IsObject() ?
+ // use current string
+ strbuf.GetString() :
+ // Unescape the string
+ JSONunescape(strbuf.GetString());
+
+ Logger::getLogger()->debug("m_bucketProperties=%s", m_bucketProperties.c_str());
+ }
+ else
+ {
+ m_bucketProperties = "";
+ }
+
+ if (m_itemType == BucketItem && m_bucketProperties.empty())
+ {
+ throw new runtime_error("Bucket configuration item is missing the \"properties\" attribute");
+ }
+
  if (item.HasMember("options"))
  {
  const Value& options = item["options"];
@@ -1095,7 +1131,7 @@ ConfigCategory::CategoryItem::CategoryItem(const string& name,
  }
  }
 
- std:string m_typeUpperCase = m_type;
+ std::string m_typeUpperCase = m_type;
  for (auto & c: m_typeUpperCase) c = toupper(c);
 
  // Item "value" can be an escaped JSON string, so check m_type JSON as well
@@ -1377,6 +1413,7 @@ ConfigCategory::CategoryItem::CategoryItem(const CategoryItem& rhs)
  m_validity = rhs.m_validity;
  m_group = rhs.m_group;
  m_rule = rhs.m_rule;
+ m_bucketProperties = rhs.m_bucketProperties;
 }
 
 /**
@@ -1467,6 +1504,11 @@ ostringstream convert;
  convert << ", \"rule\" : \"" << JSONescape(m_rule) << "\"";
  }
 
+ if (!m_bucketProperties.empty())
+ {
+ convert << ", \"properties\" : " << m_bucketProperties;
+ }
+
  if (!m_group.empty())
  {
  convert << ", \"group\" : \"" << m_group << "\"";
@@ -1538,6 +1580,11 @@ ostringstream convert;
  convert << ", \"rule\" : \"" << JSONescape(m_rule) << "\"";
  }
 
+ if (!m_bucketProperties.empty())
+ {
+ convert << ", \"properties\" : " << m_bucketProperties;
+ }
+
  if (!m_group.empty())
  {
  convert << ", \"group\" : \"" << m_group << "\"";
@@ -1587,6 +1634,31 @@ ostringstream convert;
  return convert.str();
 }
 
+/**
+ * Parse BucketItem value in JSON dict format and return the key value pairs within that
+ *
+ * @param json JSON string representing the BucketItem value
+ * @return Vector with pairs of found key/value string pairs in BucketItem value
+ */
+vector<pair<string,string>>* ConfigCategory::parseBucketItemValue(const string & json)
+{
+ Document document;
+ if (document.Parse(json.c_str()).HasParseError())
+ {
+ Logger::getLogger()->error("parseBucketItemValue(): The provided JSON string has a parse error: %s",
+ GetParseError_En(document.GetParseError()));
+ return NULL;
+ }
+
+ vector<pair<string,string>> *vec = new vector<pair<string,string>>;
+
+ for (const auto & m : document.GetObject())
+ vec->emplace_back(make_pair<string,string>(m.name.GetString(), m.value.GetString()));
+
+ return vec;
+}
+
+
 // DefaultConfigCategory constructor
 DefaultConfigCategory::DefaultConfigCategory(const string& name, const string& json) :
  ConfigCategory::ConfigCategory(name, json)

C/common/include/config_category.h

@@ -64,7 +64,8 @@ class ConfigCategory {
  DoubleItem,
  ScriptItem,
  CategoryType,
- CodeItem
+ CodeItem,
+ BucketItem
  };
 
  ConfigCategory(const std::string& name, const std::string& json);
@@ -129,13 +130,17 @@ class ConfigCategory {
  GROUP_ATTR,
  DISPLAY_NAME_ATTR,
  DEPRECATED_ATTR,
- RULE_ATTR};
+ RULE_ATTR,
+ BUCKET_PROPERTIES_ATTR
+ };
  std::string getItemAttribute(const std::string& itemName,
  ItemAttribute itemAttribute) const;
 
  bool setItemAttribute(const std::string& itemName,
  ItemAttribute itemAttribute, const std::string& value);
 
+ std::vector<std::pair<std::string,std::string>>* parseBucketItemValue(const std::string &);
+
  protected:
  class CategoryItem {
  public:
@@ -174,6 +179,7 @@ class ConfigCategory {
  std::string m_validity;
  std::string m_group;
  std::string m_rule;
+ std::string m_bucketProperties;
  };
  std::vector<CategoryItem *> m_items;
  std::string m_name;

C/common/include/service_record.h

@@ -45,6 +45,10 @@ class ServiceRecord : public JSONProvider {
  {
  m_protocol = protocol;
  }
+ const std::string& getProtocol() const
+ {
+ return m_protocol;
+ }
  void setManagementPort(const unsigned short managementPort)
  {
  m_managementPort = managementPort;

C/common/logger.cpp

@@ -46,6 +46,7 @@ static char ident[80];
  }
  openlog(ident, LOG_PID|LOG_CONS, LOG_USER);
  instance = this;
+ m_level = LOG_WARNING;
 }
 
 Logger::~Logger()

C/common/reading_set.cpp

@@ -383,7 +383,7 @@ JSONReading::JSONReading(const Value& json)
 {
  if (json.HasMember("id"))
  {
- m_id = json["id"].GetUint();
+ m_id = json["id"].GetUint64();
  m_has_id = true;
  }
  else

C/common/result_set.cpp

@@ -92,7 +92,14 @@ ResultSet::ResultSet(const std::string& json)
  switch (m_columns[colNo]->getType())
  {
  case STRING_COLUMN:
- rowValue->append(new ColumnValue(string(item->value.GetString())));
+ if (item->value.IsBool())
+ {
+ rowValue->append(new ColumnValue(item->value.IsTrue() ? "true" : "false"));
+ }
+ else
+ {
+ rowValue->append(new ColumnValue(string(item->value.GetString())));
+ }
  break;
  case INT_COLUMN:
  rowValue->append(new ColumnValue((long)(item->value.GetInt64())));
@@ -104,8 +111,10 @@ ResultSet::ResultSet(const std::string& json)
  rowValue->append(new ColumnValue(item->value));
  break;
  case BOOL_COLUMN:
- // TODO Add support
- rowValue->append(new ColumnValue(string("TODO")));
+ if (item->value.IsString())
+ rowValue->append(new ColumnValue(string(item->value.GetString())));
+ else
+ rowValue->append(new ColumnValue(item->value.IsTrue() ? "true" : "false"));
  break;
  }
  colNo++;

C/plugins/common/libcurl_https.cpp

@@ -30,6 +30,21 @@
 
 using namespace std;
 
+/**
+ * Creates a UTC time string for the current time
+ *
+ * @return Current UTC time
+ */
+static std::string CurrentTimeString()
+{
+ time_t now = time(NULL);
+ struct tm timeinfo;
+ gmtime_r(&now, &timeinfo);
+ char timeString[20];
+ strftime(timeString, sizeof(timeString), "%F %T", &timeinfo);
+ return std::string(timeString);
+}
+
 /**
  * Constructor: host:port, connect_timeout, request_timeout,
  * retry_sleep_Time, max_retry
@@ -312,6 +327,7 @@ int LibcurlHttps::sendRequest(
 
  do
  {
+ std::chrono::high_resolution_clock::time_point tStart;
  try
  {
  exceptionRaised = none;
@@ -334,6 +350,7 @@ int LibcurlHttps::sendRequest(
  }
  m_ofs << "Payload:" << endl;
  m_ofs << payload << endl;
+ tStart = std::chrono::high_resolution_clock::now();
  }
 
  // Execute the HTTP method
@@ -346,8 +363,10 @@ int LibcurlHttps::sendRequest(
  httpResponseText = httpHeaderBuffer;
  if (m_log)
  {
+ std::chrono::high_resolution_clock::time_point tEnd = std::chrono::high_resolution_clock::now();
  m_ofs << "Response:" << endl;
  m_ofs << " Code: " << httpCode << endl;
+ m_ofs << " Time: " << ((double)std::chrono::duration_cast<std::chrono::microseconds>(tEnd - tStart).count()) / 1.0E6 << " sec " << CurrentTimeString() << endl;
  m_ofs << " Content: " << httpResponseText << endl << endl;
  }
  StringStripCRLF(httpResponseText);
@@ -409,6 +428,13 @@ int LibcurlHttps::sendRequest(
  }
 #endif
 
+ if (m_log && !errorMessage.empty())
+ {
+ std::chrono::high_resolution_clock::time_point tEnd = std::chrono::high_resolution_clock::now();
+ m_ofs << " Time: " << ((double)std::chrono::duration_cast<std::chrono::microseconds>(tEnd - tStart).count()) / 1.0E6 << " sec " << CurrentTimeString() << endl;
+ m_ofs << " Exception: " << errorMessage << endl;
+ }
+
  if (retryCount < m_max_retry)
  {
  this_thread::sleep_for(chrono::seconds(sleepTime));

C/plugins/common/simple_http.cpp

@@ -17,6 +17,21 @@
 
 using namespace std;
 
+/**
+ * Creates a UTC time string for the current time
+ *
+ * @return Current UTC time
+ */
+static std::string CurrentTimeString()
+{
+ time_t now = time(NULL);
+ struct tm timeinfo;
+ gmtime_r(&now, &timeinfo);
+ char timeString[20];
+ strftime(timeString, sizeof(timeString), "%F %T", &timeinfo);
+ return std::string(timeString);
+}
+
 // Using https:/eidheim/Simple-Web-Server
 using HttpClient = SimpleWeb::Client<SimpleWeb::HTTP>;
 
@@ -126,6 +141,7 @@ int SimpleHttp::sendRequest(
 
  do
  {
+ std::chrono::high_resolution_clock::time_point tStart;
  try
  {
  exception_raised = none;
@@ -141,6 +157,7 @@ int SimpleHttp::sendRequest(
  }
  m_ofs << "Payload:" << endl;
  m_ofs << payload << endl;
+ tStart = std::chrono::high_resolution_clock::now();
  }
 
  // Call HTTPS method
@@ -151,8 +168,10 @@ int SimpleHttp::sendRequest(
 
  if (m_log)
  {
+ std::chrono::high_resolution_clock::time_point tEnd = std::chrono::high_resolution_clock::now();
  m_ofs << "Response:" << endl;
  m_ofs << " Code: " << res->status_code << endl;
+ m_ofs << " Time: " << ((double)std::chrono::duration_cast<std::chrono::microseconds>(tEnd - tStart).count()) / 1.0E6 << " sec " << CurrentTimeString() << endl;
  m_ofs << " Content: " << res->content.string() << endl << endl;
  }
 
@@ -213,6 +232,13 @@ int SimpleHttp::sendRequest(
  }
 #endif
 
+ if (m_log && !exception_message.empty())
+ {
+ std::chrono::high_resolution_clock::time_point tEnd = std::chrono::high_resolution_clock::now();
+ m_ofs << " Time: " << ((double)std::chrono::duration_cast<std::chrono::microseconds>(tEnd - tStart).count()) / 1.0E6 << " sec " << CurrentTimeString() << endl;
+ m_ofs << " Exception: " << exception_message << endl;
+ }
+
  if (retry_count < m_max_retry)
  {
  this_thread::sleep_for(chrono::seconds(sleep_time));