/// <summary>
/// Adds a meta value of a given category and entity to a cache set.
/// </summary>
/// <param name="entitykey"></param>
/// <param name="metaCategory"></param>
/// <param name="metaValue"></param>
public void AddEntityMetaCategory(string entitykey, uint metaCategory, string metaValue, bool sorted = false)
{
_lock.EnterWriteLock();
if (!_entityMetaValues.ContainsKey(metaCategory))
{
_entityMetaValues[metaCategory] = new ConcurrentDictionary <string, HashSet <string> >();
}
if (!_entityMetaValues[metaCategory].ContainsKey(entitykey))
{
_entityMetaValues[metaCategory][entitykey] = new HashSet <string>();
}
_entityMetaValues[metaCategory][entitykey].Add(metaValue);
if (sorted)
{
if (!_setFlags.ContainsKey(metaCategory))
{
_setFlags[metaCategory] = new Dictionary <string, SetFlags>();
}
if (!_setFlags[metaCategory].ContainsKey(entitykey))
{
_setFlags[metaCategory][entitykey] = new SetFlags(false);
}
_setFlags[metaCategory][entitykey] = _setFlags[metaCategory][entitykey] = new SetFlags(true);
}
if (_lock.IsWriteLockHeld)
{
_lock.ExitWriteLock();
}
}
public static StoreResult Set(string id, uint customBits, byte[] data, DateTime expire, ulong changeId, SetFlags flags)
{
string[] spl = id.Split(Config.TagCharacter);
string[] tags;
string itemId = spl[0];
if (itemId.Length == 0 || data.Length > Config.MaxStorage)
{
return(StoreResult.NotStored);
}
if (spl.Length > 1)
{
tags = new string[spl.Length - 1];
Array.Copy(spl, 1, tags, 0, tags.Length);
}
else
{
tags = null;
}
spl = null; // not needed anymore so free memory as quick as possible
lock (WriteLock) {
if (Storage.ContainsKey(itemId))
{
if ((flags & SetFlags.CheckChangeId) == SetFlags.CheckChangeId && Storage[itemId].LastChangeId != changeId)
{
return(StoreResult.Exists);
}
if ((flags & SetFlags.Replace) != SetFlags.Replace)
{
return(StoreResult.NotStored);
}
Delete(itemId, -1);
}
else if ((flags & SetFlags.Create) != SetFlags.Create)
{
return(((flags & SetFlags.CheckChangeId) == SetFlags.CheckChangeId) ? StoreResult.NotFound : StoreResult.NotStored);
}
if (StoredSize + (ulong)data.Length > (ulong)Config.MaxStorage)
{
bool clean = true;
while (StoredSize + (ulong)data.Length > (ulong)Config.MaxStorage)
{
if (clean)
{
Log.WriteLine(Log.Level.Debug, "'max_storage' limit reached. Cleaning up expired items");
// clean up all expired entries
List <string> toRemove = new List <string>();
DateTime now = DateTime.Now;
foreach (KeyValuePair <string, CacheItem> cpair in Storage)
{
if (cpair.Value.Expire <= now)
{
toRemove.Add(cpair.Key);
}
}
foreach (string remId in toRemove)
{
Delete(remId, -1);
}
clean = false;
}
else
{
Log.WriteLine(Log.Level.Debug, "Cleaning up expired items did not give us enough memory. Cleaning up old items.");
// still not enough memory .. cleanup oldest used entries
IOrderedEnumerable <KeyValuePair <string, CacheItem> > sorted = Storage.OrderBy(p => p.Value.LastUse);
long toFree = (long)data.Length - (Config.MaxStorage - (long)StoredSize);
foreach (KeyValuePair <string, CacheItem> cpair in sorted)
{
toFree -= cpair.Value.Data.Length;
Delete(cpair.Key, -1);
if (toFree <= 0)
{
break;
}
}
if (toFree > 0)
{
Log.WriteLine(Log.Level.Important, "Seems there was a memory leak. Flushing whole cache.");
Flush(-1);
break;
}
}
// too much ... need to clean up a bit
}
}
CacheItem item = new CacheItem(tags, customBits, data, expire, unchecked (NextChangeId++));
Storage.Add(itemId, item);
StoredSize += (ulong)data.Length;
if (tags != null)
{
Tag tag;
foreach (string tagId in tags)
{
if (Tags.ContainsKey(tagId))
{
tag = Tags[tagId];
}
else
{
tag = new Tag();
Tags.Add(tagId, tag);
}
tag.Items.Add(itemId);
}
}
}
return(StoreResult.Stored);
}
public static extern int DevicePowerSetDeviceState(string deviceDescription, SetFlags setFlags, IntPtr setData);
