Merge pull request #1338 from fledge-iot/2.4.0RC

2.4.0RC

C/common/asset_tracking.cpp

@@ -43,7 +43,7 @@ AssetTracker *AssetTracker::getAssetTracker()
  * @param service  		Service name
  */
 AssetTracker::AssetTracker(ManagementClient *mgtClient, string service) 
-	: m_mgtClient(mgtClient), m_service(service)
+	: m_mgtClient(mgtClient), m_service(service), m_updateInterval(MIN_ASSET_TRACKER_UPDATE)
 {
 	instance = this;
 	m_shutdown = false;
@@ -338,6 +338,27 @@ void AssetTracker::queue(TrackingTuple *tuple)
 	m_cv.notify_all();
 }
 
+/**
+ * Set the update interval for the asset tracker.
+ *
+ * @param interval The number of milliseconds between update of the asset tracker
+ * @return bool	Was the update accepted
+ */
+bool AssetTracker::tune(unsigned long interval)
+{
+	unique_lock<mutex> lck(m_mutex);
+	if (interval >= MIN_ASSET_TRACKER_UPDATE)
+	{
+		m_updateInterval = interval;
+	}
+	else
+	{
+		Logger::getLogger()->error("Attempt to set asset tracker update to less than minimum interval");
+		return false;
+	}
+	return true;
+}
+
 /**
  * The worker thread that will flush any pending asset tuples to
  * the database.
@@ -347,7 +368,7 @@ void AssetTracker::workerThread()
 	unique_lock<mutex> lck(m_mutex);
 	while (m_pending.empty() && m_shutdown == false)
 	{
-		m_cv.wait_for(lck, chrono::milliseconds(500));
+		m_cv.wait_for(lck, chrono::milliseconds(m_updateInterval));
 		processQueue();
 	}
 	// Process any items left in the queue at shutdown

C/common/base64databuffer.cpp

@@ -16,6 +16,7 @@ using namespace std;
  */
 Base64DataBuffer::Base64DataBuffer(const string& encoded)
 {
+	m_data = NULL;
 	m_itemSize = encoded[0] - '0';
 	size_t in_len = encoded.size() - 1;
 	if (in_len % 4 != 0)

C/common/config_category.cpp

@@ -144,7 +144,7 @@ ConfigCategory::ConfigCategory(const string& name, const string& json) : m_name(
 		Logger::getLogger()->error("Configuration parse error in category '%s', %s: %s at %d, '%s'",
 			name.c_str(), json.c_str(),
 			GetParseError_En(doc.GetParseError()), (unsigned)doc.GetErrorOffset(),
-			StringAround(json, (unsigned)doc.GetErrorOffset()));
+			StringAround(json, (unsigned)doc.GetErrorOffset()).c_str());
 		throw new ConfigMalformed();
 	}
 
@@ -439,6 +439,114 @@ string ConfigCategory::getValue(const string& name) const
 	throw new ConfigItemNotFound();
 }
 
+/**
+ * Return the value of the configuration category item list, this
+ * is a convience function used when simple lists are defined
+ * and allows for central processing of the list values
+ *
+ * @param name	The name of the configuration item to return
+ * @return string	The configuration item name
+ * @throws exception if the item does not exist in the category
+ */
+vector<string> ConfigCategory::getValueList(const string& name) const
+{
+	for (unsigned int i = 0; i < m_items.size(); i++)
+	{
+		if (name.compare(m_items[i]->m_name) == 0)
+		{
+			if (m_items[i]->m_type.compare("list"))
+			{
+				throw new ConfigItemNotAList();
+			}
+			Document d;
+			vector<string> list;
+			d.Parse(m_items[i]->m_value.c_str());
+			if (d.HasParseError())
+			{
+				Logger::getLogger()->error("The JSON value for a list item %s has a parse error: %s, %s",
+					name.c_str(), GetParseError_En(d.GetParseError()), m_items[i]->m_value.c_str());
+				return list;
+			}
+			if (d.IsArray())
+			{
+				for (auto& v : d.GetArray())
+				{
+					if (v.IsString())
+					{
+						list.push_back(v.GetString());
+					}
+				}
+			}
+			else
+			{
+				Logger::getLogger()->error("The value of the list item %s should be a JSON array and it is not", name.c_str());
+			}
+			return list;
+		}
+	}
+	throw new ConfigItemNotFound();
+}
+
+/**
+ * Return the value of the configuration category item kvlist, this
+ * is a convience function used when key/value lists are defined
+ * and allows for central processing of the list values
+ *
+ * @param name	The name of the configuration item to return
+ * @return string	The configuration item name
+ * @throws exception if the item does not exist in the category
+ */
+map<string, string> ConfigCategory::getValueKVList(const string& name) const
+{
+	for (unsigned int i = 0; i < m_items.size(); i++)
+	{
+		if (name.compare(m_items[i]->m_name) == 0)
+		{
+			if (m_items[i]->m_type.compare("kvlist"))
+			{
+				throw new ConfigItemNotAList();
+			}
+			map<string, string> list;
+			Document d;
+			d.Parse(m_items[i]->m_value.c_str());
+			if (d.HasParseError())
+			{
+				Logger::getLogger()->error("The JSON value for a kvlist item %s has a parse error: %s, %s",
+					name.c_str(), GetParseError_En(d.GetParseError()), m_items[i]->m_value.c_str());
+				return list;
+			}
+			for (auto& v : d.GetObject())
+			{
+				string key = v.name.GetString();
+				string value = to_string(v.value);
+				list.insert(pair<string, string>(key, value));
+			}
+			return list;
+		}
+	}
+	throw new ConfigItemNotFound();
+}
+
+/**
+ * Convert a RapidJSON value to a string
+ *
+ * @param v	The RapidJSON value
+ */
+std::string ConfigCategory::to_string(const rapidjson::Value& v) const
+{
+	if (v.IsString())
+	{
+		return { v.GetString(), v.GetStringLength() };
+	}
+	else
+	{
+		StringBuffer strbuf;
+		Writer<rapidjson::StringBuffer> writer(strbuf);
+		v.Accept(writer);
+		return { strbuf.GetString(), strbuf.GetLength() };
+	}
+}
+
 /**
  * Return the requested attribute of a configuration category item
  *
@@ -478,6 +586,10 @@ string ConfigCategory::getItemAttribute(const string& itemName,
 					return m_items[i]->m_rule;
 				case BUCKET_PROPERTIES_ATTR:
 					return m_items[i]->m_bucketProperties;
+				case LIST_SIZE_ATTR:
+					return m_items[i]->m_listSize;
+				case ITEM_TYPE_ATTR:
+					return m_items[i]->m_listItemType;
 				default:
 					throw new ConfigItemAttributeNotFound();
 			}
@@ -546,6 +658,12 @@ bool ConfigCategory::setItemAttribute(const string& itemName,
 				case BUCKET_PROPERTIES_ATTR:
 					m_items[i]->m_bucketProperties = value;
 					return true;
+				case LIST_SIZE_ATTR:
+					m_items[i]->m_listSize = value;
+					return true;
+				case ITEM_TYPE_ATTR:
+					m_items[i]->m_listItemType = value;
+					return true;
 				default:
 					return false;
 			}
@@ -882,6 +1000,44 @@ bool ConfigCategory::isDeprecated(const string& name) const
 	throw new ConfigItemNotFound();
 }
 
+/**
+ * Return if the configuration item is a list item
+ *
+ * @param name		The name of the item to test
+ * @return bool		True if the item is a Numeric type
+ * @throws exception	If the item was not found in the configuration category
+ */
+bool ConfigCategory::isList(const string& name) const
+{
+	for (unsigned int i = 0; i < m_items.size(); i++)
+	{
+		if (name.compare(m_items[i]->m_name) == 0)
+		{
+			return (m_items[i]->m_type.compare("list") == 0);
+		}
+	}
+	throw new ConfigItemNotFound();
+}
+
+/**
+ * Return if the configuration item is a kvlist item
+ *
+ * @param name		The name of the item to test
+ * @return bool		True if the item is a Numeric type
+ * @throws exception	If the item was not found in the configuration category
+ */
+bool ConfigCategory::isKVList(const string& name) const
+{
+	for (unsigned int i = 0; i < m_items.size(); i++)
+	{
+		if (name.compare(m_items[i]->m_name) == 0)
+		{
+			return (m_items[i]->m_type.compare("kvlist") == 0);
+		}
+	}
+	throw new ConfigItemNotFound();
+}
+
 /**
  * Set the description for the configuration category
  *
@@ -1047,6 +1203,14 @@ ConfigCategory::CategoryItem::CategoryItem(const string& name,
 	{
 		m_itemType = BucketItem;
 	}
+	if (m_type.compare("list") == 0)
+	{
+		m_itemType = ListItem;
+	}
+	if (m_type.compare("kvlist") == 0)
+	{
+		m_itemType = KVListItem;
+	}
 
 	if (item.HasMember("deprecated"))
 	{
@@ -1131,6 +1295,33 @@ ConfigCategory::CategoryItem::CategoryItem(const string& name,
 		}
 	}
 
+	if (item.HasMember("items"))
+	{
+		if (item["items"].IsString())
+		{
+			m_listItemType = item["items"].GetString();
+		}
+		else
+		{
+			throw new runtime_error("Items configuration item property is not a string");
+		}
+	}
+	else if (m_itemType == ListItem || m_itemType == KVListItem)
+	{
+		throw new runtime_error("List configuration item is missing the \"items\" attribute");
+	}
+	if (item.HasMember("listSize"))
+	{
+		if (item["listSize"].IsString())
+		{
+			m_listSize = item["listSize"].GetString();
+		}
+		else
+		{
+			throw new runtime_error("ListSize configuration item property is not a string");
+		}
+	}
+
 	std::string m_typeUpperCase = m_type;
 	for (auto & c: m_typeUpperCase) c = toupper(c);
 
@@ -1414,6 +1605,8 @@ ConfigCategory::CategoryItem::CategoryItem(const CategoryItem& rhs)
 	m_group = rhs.m_group;
 	m_rule = rhs.m_rule;
 	m_bucketProperties = rhs.m_bucketProperties;
+	m_listSize = rhs.m_listSize;
+	m_listItemType = rhs.m_listItemType;
 }
 
 /**
@@ -1447,7 +1640,10 @@ ostringstream convert;
 
 	if (m_itemType == StringItem ||
 	    m_itemType == BoolItem ||
-	    m_itemType == EnumerationItem)
+	    m_itemType == EnumerationItem ||
+	    m_itemType == BucketItem ||
+	    m_itemType == ListItem ||
+	    m_itemType == KVListItem)
 	{
 		convert << "\"value\" : \"" << JSONescape(m_value) << "\", ";
 		convert << "\"default\" : \"" << JSONescape(m_default) << "\"";
@@ -1461,6 +1657,10 @@ ostringstream convert;
 		convert << "\"value\" : " << m_value << ", ";
 		convert << "\"default\" : " << m_default;
 	}
+	else
+	{
+		Logger::getLogger()->error("Unknown item type in configuration category");
+	}
 
 	if (full)
 	{
@@ -1518,6 +1718,15 @@ ostringstream convert;
 		{
 			convert << ", \"file\" : \"" << m_file << "\"";
 		}
+
+		if (!m_listSize.empty())
+		{
+			convert << ", \"listSize\" : \"" << m_listSize << "\"";
+		}
+		if (!m_listItemType.empty())
+		{
+			convert << ", \"items\" : \"" << m_listItemType << "\"";
+		}
 	}
 	convert << " }";
 
@@ -1605,10 +1814,21 @@ ostringstream convert;
 		}
 		convert << "]";
 	}
+	if (!m_listSize.empty())
+	{
+		convert << ", \"listSize\" : \"" << m_listSize << "\"";
+	}
+	if (!m_listItemType.empty())
+	{
+		convert << ", \"items\" : \"" << m_listItemType << "\"";
+	}
 
 	if (m_itemType == StringItem ||
 	    m_itemType == EnumerationItem ||
-	    m_itemType == BoolItem)
+	    m_itemType == BoolItem ||
+	    m_itemType == BucketItem ||
+	    m_itemType == ListItem ||
+	    m_itemType == KVListItem)
 	{
 		convert << ", \"default\" : \"" << JSONescape(m_default) << "\" }";
 	}