public IndexAddTask(QueryIndexManager indexManager, object key, CacheEntry value, OperationContext operationContext)
{
_key = key;
_entry = value;
_indexManager = indexManager;
_operationContext = operationContext;
}
public void Intercept(IInvocation invocation)
{
var cacheKey = string.Format("{0}||{1}", invocation.Method.Name, invocation.Method.DeclaringType.Name);
if (_cache.ContainsKey(cacheKey))
{
var entry = _cache[cacheKey];
if (DateTime.Now < entry.Expiry)
{
invocation.ReturnValue = entry.ReturnValue;
return;
}
}
invocation.Proceed();
// Can we cache this entry?
if (invocation.MethodInvocationTarget.GetCustomAttributes(typeof (CacheAttribute), true).Length == 0)
return;
var newEntry = new CacheEntry()
{
Expiry = DateTime.Now.AddSeconds(5),
ReturnValue = invocation.ReturnValue
};
_cache[cacheKey] = newEntry;
}
public static async Task<long?> GetPrimePlatSellOrders(string primeName)
{
CacheEntry<long?> cacheItem;
if (_marketCache.TryGetValue(primeName, out cacheItem))
{
if (!cacheItem.IsExpired(_expirationTimespan))
{
return cacheItem.Value;
}
}
var textInfo = new CultureInfo("en-US", false).TextInfo;
var partName = textInfo.ToTitleCase(primeName.ToLower());
if (_removeBPSuffixPhrases.Any(suffix => partName.EndsWith(suffix + " Blueprint")))
{
partName = partName.Replace(" Blueprint", "");
}
// Since Warframe.Market is still using the term Helmet instead of the new one, TODO: this might change
partName = partName.Replace("Neuroptics", "Helmet");
if (_fixedQueryStrings.ContainsKey(partName))
{
//Some of Warframe.Market's query strings are mangled (extra spaces, misspellings, words missing) fix them manually...
partName = _fixedQueryStrings[partName];
}
string jsonData;
using (var client = new WebClient())
{
var uri = new Uri(_baseUrl + Uri.EscapeDataString(partName));
try
{
jsonData = await client.DownloadStringTaskAsync(uri);
dynamic result = JsonConvert.DeserializeObject(jsonData);
// when the server responds anything that is not 200 (HTTP OK) don't bother doing something else
if (result.code != 200)
{
Debug.WriteLine($"Error with {partName}, Status Code: {result.code.Value}");
_marketCache[primeName] = new CacheEntry<long?>(null);
return null;
}
IEnumerable<dynamic> sellOrders = result.response.sell;
long? smallestPrice = sellOrders.Where(order => order.online_status).Min(order => order.price);
_marketCache[primeName] = new CacheEntry<long?>(smallestPrice);
return smallestPrice;
}
catch
{
return null;
}
}
}
public bool Insert(Segment seg)
{
Debug.Assert(Exists(seg.SegmentID) == false);
int pos = (int)(seg.SegmentID % m_size);
CacheEntry head = m_data[pos];
if (head == null)
m_data[pos] = new CacheEntry(seg);
else
{
while (head.Next != null &&head.Segment.SegmentID != seg.SegmentID)
{
head = head.Next;
}
if (head.Segment.SegmentID == seg.SegmentID)
return false;
else
{
head.Next = new CacheEntry(seg,null);
}
}
m_count ++;
return true;
}
private CacheEntry CreateCacheEntry(Type type)
{
var encoderType = typeof(IFrameEncoder<>).MakeGenericType(type);
// Func<object, Stream, object, Task> callback = (encoder, body, value) =>
// {
// return ((IStreamEncoder<T>)encoder).Encode(body, (T)value);
// }
var encoderParam = Expression.Parameter(typeof(object), "encoder");
var bodyParam = Expression.Parameter(typeof(Stream), "body");
var valueParam = Expression.Parameter(typeof(object), "value");
var encoderCast = Expression.Convert(encoderParam, encoderType);
var valueCast = Expression.Convert(valueParam, type);
var encode = encoderType.GetMethod("Encode", BindingFlags.Public | BindingFlags.Instance);
var encodeCall = Expression.Call(encoderCast, encode, bodyParam, valueCast);
var lambda = Expression.Lambda<Func<object, Stream, object, Task>>(encodeCall, encoderParam, bodyParam, valueParam);
var entry = new CacheEntry
{
Encode = lambda.Compile(),
Encoder = _serviceProvider.GetRequiredService(encoderType)
};
return entry;
}
public CacheEntry Lookup(string fullname)
{
string[] names = fullname.Split('\\');
CacheEntry current = this;
CacheEntry child = null;
foreach (string entry in names)
{
if (current.Children == null)
current.Children = new Dictionary<string, CacheEntry>();
if (current.Children.TryGetValue(entry, out child))
{
current = child;
}
else
{
CacheEntry cache = new CacheEntry(entry);
current.Children[entry] = cache;
cache.Parent = current;
current = cache;
}
}
return current;
}
public void Id_ShouldReturnCorrectValue(
[Frozen]Guid id,
CacheEntry<object> sut)
{
//assert
sut.Id.Should().Be(id);
}
/// <summary>
/// Returns a Matrix with the data for the TimeStep, Item
/// TimeStep counts from 0, Item from 1.
/// Lower left in Matrix is (0,0)
/// </summary>
/// <param name="TimeStep"></param>
/// <param name="Item"></param>
/// <param name="Layer"></param>
/// <returns></returns>
public Matrix GetData(int TimeStep, int Item)
{
CacheEntry cen;
Dictionary<int, CacheEntry> _timeValues;
if (!_bufferData.TryGetValue(Item, out _timeValues))
{
_timeValues = new Dictionary<int, CacheEntry>();
_bufferData.Add(Item, _timeValues);
}
if (!_timeValues.TryGetValue(TimeStep, out cen))
{
ReadItemTimeStep(TimeStep, Item);
Matrix _data = new Matrix(_numberOfRows, _numberOfColumns);
int m = 0;
for (int i = 0; i < _numberOfRows; i++)
for (int j = 0; j < _numberOfColumns; j++)
{
_data[i, j] = dfsdata[m];
m++;
}
cen = new CacheEntry(AbsoluteFileName, Item, TimeStep, _data);
_timeValues.Add(TimeStep, cen);
CheckBuffer();
}
else
AccessList.Remove(cen);
AccessList.AddLast(cen);
return cen.Data;
}
public static void Cache(DiagnosticAnalyzer analyzer, object key, CacheEntry entry)
{
AssertKey(key);
// add new cache entry
var analyzerMap = s_map.GetOrAdd(analyzer, _ => new ConcurrentDictionary<object, CacheEntry>(concurrencyLevel: 2, capacity: 10));
analyzerMap[key] = entry;
}
public async Task AddEntryAsync(CacheEntry entry, HttpResponseMessage response)
{
CacheEntryContainer cacheEntryContainer = GetOrCreateContainer(entry.Key);
lock (syncRoot)
{
cacheEntryContainer.Entries.Add(entry);
_responseCache[entry.VariantId] = response;
}
}
public void Sanity()
{
var ceStr = new CacheEntry<string>(1, "3");
Assert.AreEqual(DateTime.MinValue, ceStr.LastAccessed);
Assert.AreEqual(1, ceStr.Key);
Assert.AreEqual("3", ceStr.Val);
Assert.IsTrue(ceStr.LastAccessed.AddMinutes(1) > DateTime.Now);
}
public async Task<CacheContent> GetContentAsync(CacheEntry cacheEntry, string secondaryKey)
{
var inMemoryCacheEntry = _responseCache[cacheEntry.Key];
if (inMemoryCacheEntry.Responses.ContainsKey(secondaryKey))
{
return await CloneAsync(inMemoryCacheEntry.Responses[secondaryKey]);
}
return null;
}
public static object GetInstanceOf(Type providerType, object[] providerArgs)
{
CacheEntry entry = new CacheEntry(providerType, providerArgs);
object instance = instances[entry];
return instance == null
? instances[entry] = Reflect.Construct(providerType, providerArgs)
: instance;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="listener"></param>
/// <param name="data"></param>
public AsyncBroadcastCustomNotifyRemoval(ClusterCacheBase parent, object key, CacheEntry entry, ItemRemoveReason reason, OperationContext operationContext, EventContext eventContext)
{
_parent = parent;
_key = key;
_entry = entry;
_reason = reason;
_operationContext = operationContext;
_eventContext = eventContext;
}
public static CacheEntry Create(object rawValue, DateTime createdAt, object options = null)
{
var opts = options.AsDictionary();
var entry = new CacheEntry(null);
entry.Value = rawValue;
entry.CreatedAt = createdAt;
entry.Compressed = opts["compressed"].AsBoolean();
return entry;
}
private void addToCache(string fileName, CacheEntry entry)
{
_cache[fileName] = entry;
calculateTotalSize();
while (_totalBytes > _maxBytes)
{
deleteOldest();
}
}
public static CacheQueryResult ReturnStored(CacheEntry cacheEntry, HttpResponseMessage response)
{
HttpCache.UpdateAgeHeader(response);
return new CacheQueryResult()
{
Status = CacheStatus.ReturnStored,
SelectedEntry = cacheEntry,
SelectedResponse = response
};
}
private void PropagateCacheDependencies(CacheEntry entry)
{
// Bubble up volatile tokens to parent context
if (_accessor.Current != null)
{
foreach (var dependency in entry.Dependencies)
{
_accessor.Current.Monitor(dependency);
}
}
}
public void TestHashCode()
{
var entry1 = new CacheEntry<int, int>(1, 2);
var entry2 = new CacheEntry<int, int>(1, 2);
var entry3 = new CacheEntry<int, int>(1, 3);
var set = new HashSet<object> {entry1};
Assert.IsTrue(set.Contains(entry1));
Assert.IsTrue(set.Contains(entry2));
Assert.IsFalse(set.Contains(entry3));
}
public virtual void AddToCache(string commandText, object resultSet)
{
CleanCache();
CacheEntry entry = new CacheEntry();
entry.CacheTime = DateTime.Now;
entry.CacheElement = resultSet;
lock (cache)
{
if (cache.ContainsKey(commandText)) return;
cache.Add(commandText, entry);
}
}
public void Reload (CacheEntry entry, object data, int width, int height)
{
lock (items) {
lock (entry) {
entry.Reload = true;
entry.Width = width;
entry.Height = height;
entry.Data = data;
}
Monitor.Pulse (items);
}
}
public async Task UpdateEntryAsync(CacheEntry entry, HttpResponseMessage response)
{
CacheEntryContainer cacheEntryContainer = GetOrCreateContainer(entry.Key);
lock (syncRoot)
{
var oldentry = cacheEntryContainer.Entries.First(e => e.VariantId == entry.VariantId);
cacheEntryContainer.Entries.Remove(oldentry);
cacheEntryContainer.Entries.Add(entry);
_responseCache[entry.VariantId] = response;
}
}
public void Value_ShouldReturnCorrectValue(
Guid id,
string cacheKey,
Dictionary<string, string> attributes,
object value,
DateTimeOffset date)
{
//arrange
var sut = new CacheEntry<object>(id, cacheKey, attributes, date, value);
//assert
sut.Value.Should().Be(value);
}
public static bool TryGetValue(DiagnosticAnalyzer analyzer, object key, out CacheEntry entry)
{
AssertKey(key);
entry = default(CacheEntry);
if (!s_map.TryGetValue(analyzer, out var analyzerMap) ||
!analyzerMap.TryGetValue(key, out entry))
{
return false;
}
return true;
}
public static object GetInstanceOf(Type providerType, object[] providerArgs)
{
CacheEntry entry = new CacheEntry(providerType, providerArgs);
object instance = instances.ContainsKey(entry)
?instances[entry]
: null;
if (instance == null)
instances[entry] = instance = Reflect.Construct(providerType, providerArgs);
return instance;
}
public Guid Add(Guid persistentUserIdentifier, DateTime expiryTimeUtc)
{
var key = Guid.NewGuid();
var newEntry = new CacheEntry
{
ExpiryTime = expiryTimeUtc,
PersistentUserIdentifier = persistentUserIdentifier
};
cache[key] = newEntry;
return key;
}
public void cache_entry_should_support_this_type()
{
var someData = new SomeData
{
stringValue = "qwerty",
intValue = 12345,
boolValue = false,
stringArray = new[] { "q", "w", "e" }
};
var cacheEntry = new CacheEntry<SomeData> {Value = someData};
var stream = ProtoBufSerializer.Serialize(cacheEntry);
stream.Should().NotBeNull();
ProtoBufSerializer.Deserialize<CacheEntry<SomeData>>(stream).ShouldBeEquivalentTo(cacheEntry, options => options.Excluding(x=>x.Value));
}
public void AddOrUpdate(string key, Bitmap bmp, TimeSpan duration)
{
key = SanitizeKey (key);
lock (entries) {
bool existed = entries.ContainsKey (key);
using (var stream = new BufferedStream (File.OpenWrite (Path.Combine (basePath, key))))
bmp.Compress (Bitmap.CompressFormat.Png, 100, stream);
AppendToJournal (existed ? JournalOp.Modified : JournalOp.Created,
key,
DateTime.UtcNow,
duration);
entries[key] = new CacheEntry (DateTime.UtcNow, duration);
}
}
public async Task Get_WhenValueIsUpdated_ShouldReturnCorrectValue(
MemoryCacheEntryRepository sut,
CacheEntry<object> cacheEntry,
object newValue)
{
//arrange
var expected = new CacheEntry<object>(cacheEntry.Id, cacheEntry.CacheKey, cacheEntry.Attributes, DateTimeOffset.Now, newValue);
await sut.AddOrUpdate(CancellationToken.None, cacheEntry);
await sut.AddOrUpdate(CancellationToken.None, expected);
//act
var actual = await sut.Get<object>(CancellationToken.None, expected.CacheKey, expected.Attributes);
//assert
actual.Should().Be(expected);
}
public async Task Get_WhenValueExists_ShouldReturnCorrectValue(
MemoryCacheEntryRepository sut,
[Frozen]Dictionary<string, string> attributes,
[Frozen]string cacheKey,
[Frozen]Guid id,
CacheEntry<object> expected)
{
//arrange
await sut.AddOrUpdate(CancellationToken.None, expected);
//act
var actual = await sut.Get<object>(CancellationToken.None, expected.CacheKey, expected.Attributes);
//assert
actual.Should().Be(expected);
}
public static void Set(string key, string data)
{
cache[key] = new CacheEntry(data, Data.TTL);
}
private static IEnumerable <CacheEntry> GetCacheUsage(IEnumerable <LogEntry> logEntries)
{
var cacheMisses = new List <LogEntry>();
var cacheEntries = new List <CacheEntry>();
var lastCacheEntryByKey = new Dictionary <string, CacheEntry>();
foreach (var logEntry in logEntries)
{
if (CacheEntry.IsCacheFill(logEntry))
{
var cacheEntry = new CacheEntry(logEntry);
cacheEntries.Add(cacheEntry);
lastCacheEntryByKey[cacheEntry.Key] = cacheEntry;
}
else if (CacheEntry.IsCacheHit(logEntry) && lastCacheEntryByKey.TryGetValue(CacheEntry.GetKeyFromCacheHit(logEntry), out var cacheEntry))
{
cacheEntry.AddHit(logEntry);
}
//else if (CacheEntry.IsCacheMiss(logEntry))
//{
// cacheMisses.Add(logEntry);
//}
}
//var cacheMissesByKey = cacheMisses.ToLookup(CacheEntry.GetKeyFromCacheMiss);
//foreach (var cacheEntry in cacheEntries)
//{
//}
return(cacheEntries);
}
public override void Execute()
{
ISessionImplementor session = Session;
object id = Id;
IEntityPersister persister = Persister;
object instance = Instance;
bool statsEnabled = Session.Factory.Statistics.IsStatisticsEnabled;
Stopwatch stopwatch = null;
if (statsEnabled)
{
stopwatch = Stopwatch.StartNew();
}
bool veto = PreUpdate();
ISessionFactoryImplementor factory = Session.Factory;
if (persister.IsVersionPropertyGenerated)
{
// we need to grab the version value from the entity, otherwise
// we have issues with generated-version entities that may have
// multiple actions queued during the same flush
previousVersion = persister.GetVersion(instance);
}
CacheKey ck = null;
if (persister.HasCache)
{
ck = session.GenerateCacheKey(id, persister.IdentifierType, persister.RootEntityName);
slock = persister.Cache.Lock(ck, previousVersion);
}
if (!veto)
{
persister.Update(id, state, dirtyFields, hasDirtyCollection, previousState, previousVersion, instance, null, session);
}
EntityEntry entry = Session.PersistenceContext.GetEntry(instance);
if (entry == null)
{
throw new AssertionFailure("Possible nonthreadsafe access to session");
}
if (entry.Status == Status.Loaded || persister.IsVersionPropertyGenerated)
{
// get the updated snapshot of the entity state by cloning current state;
// it is safe to copy in place, since by this time no-one else (should have)
// has a reference to the array
TypeHelper.DeepCopy(state, persister.PropertyTypes, persister.PropertyCheckability, state, Session);
if (persister.HasUpdateGeneratedProperties)
{
// this entity defines property generation, so process those generated
// values...
persister.ProcessUpdateGeneratedProperties(id, instance, state, Session);
if (persister.IsVersionPropertyGenerated)
{
nextVersion = Versioning.GetVersion(state, persister);
}
}
// have the entity entry perform post-update processing, passing it the
// update state and the new version (if one).
entry.PostUpdate(instance, state, nextVersion);
}
if (persister.HasCache)
{
if (persister.IsCacheInvalidationRequired || entry.Status != Status.Loaded)
{
persister.Cache.Evict(ck);
}
else
{
CacheEntry ce = new CacheEntry(state, persister, persister.HasUninitializedLazyProperties(instance), nextVersion, Session, instance);
cacheEntry = persister.CacheEntryStructure.Structure(ce);
bool put = persister.Cache.Update(ck, cacheEntry, nextVersion, previousVersion);
if (put && factory.Statistics.IsStatisticsEnabled)
{
factory.StatisticsImplementor.SecondLevelCachePut(Persister.Cache.RegionName);
}
}
}
PostUpdate();
if (statsEnabled && !veto)
{
stopwatch.Stop();
factory.StatisticsImplementor.UpdateEntity(Persister.EntityName, stopwatch.Elapsed);
}
}
public override object RemoveSync(object[] keys, ItemRemoveReason reason, bool notify, OperationContext operationContext)
{
ArrayList depenedentItemList = new ArrayList();
try
{
Hashtable totalRemovedItems = new Hashtable();
CacheEntry entry = null;
IDictionaryEnumerator ide = null;
for (int i = 0; i < keys.Length; i++)
{
try
{
if (keys[i] != null)
{
entry = Internal.Remove(keys[i], reason, false, null, LockAccessType.IGNORE_LOCK, operationContext);
}
if (entry != null)
{
totalRemovedItems.Add(keys[i], entry);
}
}
catch (Exception ex)
{
}
}
ide = totalRemovedItems.GetEnumerator();
while (ide.MoveNext())
{
try
{
entry = ide.Value as CacheEntry;
if (entry != null)
{
if (entry.Value is CallbackEntry)
{
EventId eventId = null;
OperationID opId = operationContext.OperatoinID;
CallbackEntry cbEtnry = (CallbackEntry)entry.Value;
EventContext eventContext = null;
if (cbEtnry != null && cbEtnry.ItemRemoveCallbackListener != null && cbEtnry.ItemRemoveCallbackListener.Count > 0)
{
//generate event id
if (!operationContext.Contains(OperationContextFieldName.EventContext)) //for atomic operations
{
eventId = EventId.CreateEventId(opId);
}
else //for bulk
{
eventId = ((EventContext)operationContext.GetValueByField(OperationContextFieldName.EventContext)).EventID;
}
eventId.EventType = EventType.ITEM_REMOVED_CALLBACK;
eventContext = new EventContext();
eventContext.Add(EventContextFieldName.EventID, eventId);
EventCacheEntry eventCacheEntry = CacheHelper.CreateCacheEventEntry(cbEtnry.ItemRemoveCallbackListener, entry);
eventContext.Item = eventCacheEntry;
eventContext.Add(EventContextFieldName.ItemRemoveCallbackList, cbEtnry.ItemRemoveCallbackListener.Clone());
//Will always reaise the whole entry for old clients
NotifyCustomRemoveCallback(ide.Key, entry, reason, true, operationContext, eventContext);
}
}
}
}
catch (Exception ex)
{
}
}
}
catch (Exception)
{
throw;
}
return(depenedentItemList);
}
public async Task TestHistoricMetadataPathStringRoundtrip()
{
LoggingContext loggingContext = CreateLoggingContextForTest();
PipExecutionContext context;
HistoricMetadataCache cache = null;
var hmcFolderName = "hmc";
for (int i = 0; i < 3; i++)
{
CreateHistoricCache(loggingContext, hmcFolderName, out context, out cache, out var memoryArtifactCache);
var process1 = CreateDummyProcess(context, new PipId(1));
var process2 = CreateDummyProcess(context, new PipId(2));
var pathTable = context.PathTable;
// Add some random paths to ensure path table indices are different after loading
AbsolutePath.Create(pathTable, X("/H/aslj/sfas/832.stxt"));
AbsolutePath.Create(pathTable, X("/R/f/s/Historic"));
AbsolutePath.Create(pathTable, X("/M/hgf/sf4as/83afsd"));
AbsolutePath.Create(pathTable, X("/Z/bd/sfas/Cache"));
var abPath1 = AbsolutePath.Create(pathTable, X("/H/aslj/sfas/p1OUT.bin"));
var abPath2 = AbsolutePath.Create(pathTable, X("/H/aslj/sfas/P2.txt"));
var pathSet1 = ObservedPathSetTestUtilities.CreatePathSet(
pathTable,
X("/X/a/b/c"),
X("/X/d/e"),
X("/X/a/b/c/d"));
PipCacheDescriptorV2Metadata metadata1 =
new PipCacheDescriptorV2Metadata
{
StaticOutputHashes = new List <AbsolutePathFileMaterializationInfo>
{
new AbsolutePathFileMaterializationInfo
{
AbsolutePath = abPath1.GetName(pathTable).ToString(context.StringTable),
Info = new BondFileMaterializationInfo {
FileName = "p1OUT.bin"
}
}
}
};
var storedPathSet1 = await cache.TryStorePathSetAsync(pathSet1);
var storedMetadata1 = await cache.TryStoreMetadataAsync(metadata1);
var weakFingerprint1 = new WeakContentFingerprint(FingerprintUtilities.CreateRandom());
var strongFingerprint1 = new StrongContentFingerprint(FingerprintUtilities.CreateRandom());
var cacheEntry = new CacheEntry(storedMetadata1.Result, nameof(HistoricMetadataCacheTests), ArrayView <ContentHash> .Empty);
var publishedCacheEntry = await cache.TryPublishCacheEntryAsync(process1, weakFingerprint1, storedPathSet1.Result, strongFingerprint1, cacheEntry);
var pathSet2 = ObservedPathSetTestUtilities.CreatePathSet(
pathTable,
X("/F/a/y/c"),
X("/B/d/e"),
X("/G/a/z/c/d"),
X("/B/a/b/c"));
PipCacheDescriptorV2Metadata metadata2 =
new PipCacheDescriptorV2Metadata
{
StaticOutputHashes = new List <AbsolutePathFileMaterializationInfo>
{
new AbsolutePathFileMaterializationInfo
{
AbsolutePath = abPath2.ToString(pathTable),
Info = new BondFileMaterializationInfo {
FileName = abPath2.GetName(pathTable).ToString(context.StringTable)
}
}
},
DynamicOutputs = new List <List <RelativePathFileMaterializationInfo> >
{
new List <RelativePathFileMaterializationInfo>
{
new RelativePathFileMaterializationInfo
{
RelativePath = @"dir\P2Dynamic.txt",
Info = new BondFileMaterializationInfo {
FileName = "p2dynamic.txt"
}
},
new RelativePathFileMaterializationInfo
{
RelativePath = @"dir\P2dynout2.txt",
Info = new BondFileMaterializationInfo {
FileName = null
}
}
}
}
};
var storedPathSet2 = await cache.TryStorePathSetAsync(pathSet2);
var storedMetadata2 = await cache.TryStoreMetadataAsync(metadata2);
var cacheEntry2 = new CacheEntry(storedMetadata2.Result, nameof(HistoricMetadataCacheTests), ArrayView <ContentHash> .Empty);
var strongFingerprint2 = new StrongContentFingerprint(FingerprintUtilities.CreateRandom());
var publishedCacheEntry2 = await cache.TryPublishCacheEntryAsync(process1, weakFingerprint1, storedPathSet2.Result, strongFingerprint2, cacheEntry2);
await cache.CloseAsync();
memoryArtifactCache.Clear();
PipExecutionContext loadedContext;
HistoricMetadataCache loadedCache;
TaskSourceSlim <bool> loadCompletionSource = TaskSourceSlim.Create <bool>();
TaskSourceSlim <bool> loadCalled = TaskSourceSlim.Create <bool>();
BoxRef <bool> calledLoad = new BoxRef <bool>();
CreateHistoricCache(loggingContext, "hmc", out loadedContext, out loadedCache, out memoryArtifactCache, loadTask: async hmc =>
{
loadCalled.SetResult(true);
await loadCompletionSource.Task;
});
var operationContext = OperationContext.CreateUntracked(loggingContext);
var retrievePathSet1Task = loadedCache.TryRetrievePathSetAsync(operationContext, WeakContentFingerprint.Zero, storedPathSet1.Result);
var retrievdMetadata1Task = loadedCache.TryRetrieveMetadataAsync(
process1,
WeakContentFingerprint.Zero,
StrongContentFingerprint.Zero,
storedMetadata1.Result,
storedPathSet1.Result);
var getCacheEntry1Task = loadedCache.TryGetCacheEntryAsync(
process1,
weakFingerprint1,
storedPathSet1.Result,
strongFingerprint1);
Assert.False(retrievePathSet1Task.IsCompleted, "Before load task completes. TryRetrievePathSetAsync operations should block");
Assert.False(retrievdMetadata1Task.IsCompleted, "Before load task completes. TryRetrieveMetadataAsync operations should block");
Assert.False(getCacheEntry1Task.IsCompleted, "Before load task completes. TryGetCacheEntryAsync operations should block");
Assert.True(loadCalled.Task.Wait(TimeSpan.FromSeconds(10)) && loadCalled.Task.Result, "Load should have been called in as a result of querying");
loadCompletionSource.SetResult(true);
var maybeLoadedPathSet1 = await retrievePathSet1Task;
var maybeLoadedMetadata1 = await retrievdMetadata1Task;
var maybeLoadedCacheEntry1 = await getCacheEntry1Task;
Assert.Equal(storedMetadata1.Result, maybeLoadedCacheEntry1.Result.Value.MetadataHash);
var maybeLoadedPathSet2 = await loadedCache.TryRetrievePathSetAsync(operationContext, WeakContentFingerprint.Zero, storedPathSet2.Result);
var maybeLoadedMetadata2 = await loadedCache.TryRetrieveMetadataAsync(
process2,
WeakContentFingerprint.Zero,
StrongContentFingerprint.Zero,
storedMetadata2.Result,
storedPathSet2.Result);
AssertPathSetEquals(pathTable, pathSet1, loadedContext.PathTable, maybeLoadedPathSet1.Result);
AssertPathSetEquals(pathTable, pathSet2, loadedContext.PathTable, maybeLoadedPathSet2.Result);
AssertMetadataEquals(metadata1, maybeLoadedMetadata1.Result);
AssertMetadataEquals(metadata2, maybeLoadedMetadata2.Result);
await loadedCache.CloseAsync();
}
}
void ICompactSerializable.Deserialize(CompactReader reader)
{
_entry = (CacheEntry)reader.ReadObject();
_result = (CacheInsResult)reader.ReadObject();
}
/// <summary>
/// constructor
/// </summary>
/// <param name="entry"></param>
/// <param name="result"></param>
public CacheInsResultWithEntry(CacheEntry entry, CacheInsResult result)
{
_entry = entry;
_result = result;
}
public override void Execute()
{
IEntityPersister persister = Persister;
ISessionImplementor session = Session;
object instance = Instance;
object id = Id;
bool statsEnabled = Session.Factory.Statistics.IsStatisticsEnabled;
Stopwatch stopwatch = null;
if (statsEnabled)
{
stopwatch = Stopwatch.StartNew();
}
bool veto = PreInsert();
var wasDelayed = false;
// Don't need to lock the cache here, since if someone
// else inserted the same pk first, the insert would fail
if (!veto)
{
// The identifier may be a foreign delayed identifier, which at this point should have been resolved.
if (id is DelayedPostInsertIdentifier delayed)
{
wasDelayed = true;
id = delayed.ActualId ??
throw new InvalidOperationException(
$"The delayed foreign identifier {delayed} has not been resolved before insertion of a {instance}");
}
persister.Insert(id, State, instance, Session);
EntityEntry entry = Session.PersistenceContext.GetEntry(instance);
if (entry == null)
{
throw new AssertionFailure("Possible nonthreadsafe access to session");
}
entry.PostInsert();
if (wasDelayed)
{
Session.PersistenceContext.ReplaceDelayedEntityIdentityInsertKeys(entry.EntityKey, id);
}
if (persister.HasInsertGeneratedProperties)
{
persister.ProcessInsertGeneratedProperties(id, instance, State, Session);
if (persister.IsVersionPropertyGenerated)
{
version = Versioning.GetVersion(State, persister);
}
entry.PostUpdate(instance, State, version);
}
}
ISessionFactoryImplementor factory = Session.Factory;
if (IsCachePutEnabled(persister))
{
CacheEntry ce = CacheEntry.Create(State, persister, version, session, instance);
cacheEntry = persister.CacheEntryStructure.Structure(ce);
CacheKey ck = Session.GenerateCacheKey(id, persister.IdentifierType, persister.RootEntityName);
bool put = persister.Cache.Insert(ck, cacheEntry, version);
if (put && factory.Statistics.IsStatisticsEnabled)
{
factory.StatisticsImplementor.SecondLevelCachePut(Persister.Cache.RegionName);
}
}
PostInsert();
if (statsEnabled && !veto)
{
stopwatch.Stop();
factory.StatisticsImplementor.InsertEntity(Persister.EntityName, stopwatch.Elapsed);
}
}
public override void Execute()
{
IEntityPersister persister = Persister;
ISessionImplementor session = Session;
object instance = Instance;
object id = Id;
bool statsEnabled = Session.Factory.Statistics.IsStatisticsEnabled;
Stopwatch stopwatch = null;
if (statsEnabled)
{
stopwatch = Stopwatch.StartNew();
}
bool veto = PreInsert();
// Don't need to lock the cache here, since if someone
// else inserted the same pk first, the insert would fail
if (!veto)
{
persister.Insert(id, state, instance, Session);
EntityEntry entry = Session.PersistenceContext.GetEntry(instance);
if (entry == null)
{
throw new AssertionFailure("Possible nonthreadsafe access to session");
}
entry.PostInsert();
if (persister.HasInsertGeneratedProperties)
{
persister.ProcessInsertGeneratedProperties(id, instance, state, Session);
if (persister.IsVersionPropertyGenerated)
{
version = Versioning.GetVersion(state, persister);
}
entry.PostUpdate(instance, state, version);
}
}
ISessionFactoryImplementor factory = Session.Factory;
if (IsCachePutEnabled(persister))
{
CacheEntry ce = new CacheEntry(state, persister, persister.HasUninitializedLazyProperties(instance), version, session, instance);
cacheEntry = persister.CacheEntryStructure.Structure(ce);
CacheKey ck = Session.GenerateCacheKey(id, persister.IdentifierType, persister.RootEntityName);
bool put = persister.Cache.Insert(ck, cacheEntry, version);
if (put && factory.Statistics.IsStatisticsEnabled)
{
factory.StatisticsImplementor.SecondLevelCachePut(Persister.Cache.RegionName);
}
}
PostInsert();
if (statsEnabled && !veto)
{
stopwatch.Stop();
factory.StatisticsImplementor.InsertEntity(Persister.EntityName, stopwatch.Elapsed);
}
}
private static bool EntryExpired(CacheEntry entry, DateTimeOffset now)
{
return(entry.AbsoluteExpiration < now || (now - entry.LastAccess) > entry.SlidingExpiration);
}
public void Update(CacheEntry entry, Gdk.Pixbuf pixbuf)
{
lock (items) {
entry.SetPixbufExtended(pixbuf, true);
}
}
/// <summary>
/// Perform the second step of 2-phase load. Fully initialize the entity instance.
/// After processing a JDBC result set, we "resolve" all the associations
/// between the entities which were instantiated and had their state
/// "hydrated" into an array
/// </summary>
public static async Task InitializeEntityAsync(object entity, bool readOnly, ISessionImplementor session, PreLoadEvent preLoadEvent, PostLoadEvent postLoadEvent, CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
//TODO: Should this be an InitializeEntityEventListener??? (watch out for performance!)
bool statsEnabled = session.Factory.Statistics.IsStatisticsEnabled;
var stopWath = new Stopwatch();
if (statsEnabled)
{
stopWath.Start();
}
IPersistenceContext persistenceContext = session.PersistenceContext;
EntityEntry entityEntry = persistenceContext.GetEntry(entity);
if (entityEntry == null)
{
throw new AssertionFailure("possible non-threadsafe access to the session");
}
IEntityPersister persister = entityEntry.Persister;
object id = entityEntry.Id;
object[] hydratedState = entityEntry.LoadedState;
if (log.IsDebugEnabled())
{
log.Debug("resolving associations for {0}", MessageHelper.InfoString(persister, id, session.Factory));
}
IType[] types = persister.PropertyTypes;
for (int i = 0; i < hydratedState.Length; i++)
{
object value = hydratedState[i];
if (!Equals(LazyPropertyInitializer.UnfetchedProperty, value) && !(Equals(BackrefPropertyAccessor.Unknown, value)))
{
hydratedState[i] = await(types[i].ResolveIdentifierAsync(value, session, entity, cancellationToken)).ConfigureAwait(false);
}
}
//Must occur after resolving identifiers!
if (session.IsEventSource)
{
preLoadEvent.Entity = entity;
preLoadEvent.State = hydratedState;
preLoadEvent.Id = id;
preLoadEvent.Persister = persister;
IPreLoadEventListener[] listeners = session.Listeners.PreLoadEventListeners;
for (int i = 0; i < listeners.Length; i++)
{
await(listeners[i].OnPreLoadAsync(preLoadEvent, cancellationToken)).ConfigureAwait(false);
}
}
persister.SetPropertyValues(entity, hydratedState);
ISessionFactoryImplementor factory = session.Factory;
if (persister.HasCache && session.CacheMode.HasFlag(CacheMode.Put))
{
if (log.IsDebugEnabled())
{
log.Debug("adding entity to second-level cache: {0}", MessageHelper.InfoString(persister, id, session.Factory));
}
object version = Versioning.GetVersion(hydratedState, persister);
CacheEntry entry =
new CacheEntry(hydratedState, persister, entityEntry.LoadedWithLazyPropertiesUnfetched, version, session, entity);
CacheKey cacheKey = session.GenerateCacheKey(id, persister.IdentifierType, persister.RootEntityName);
bool put =
await(persister.Cache.PutAsync(cacheKey, persister.CacheEntryStructure.Structure(entry), session.Timestamp, version,
persister.IsVersioned ? persister.VersionType.Comparator : null,
UseMinimalPuts(session, entityEntry), cancellationToken)).ConfigureAwait(false);
if (put && factory.Statistics.IsStatisticsEnabled)
{
factory.StatisticsImplementor.SecondLevelCachePut(persister.Cache.RegionName);
}
}
bool isReallyReadOnly = readOnly;
if (!persister.IsMutable)
{
isReallyReadOnly = true;
}
else
{
object proxy = persistenceContext.GetProxy(entityEntry.EntityKey);
if (proxy != null)
{
// there is already a proxy for this impl
// only set the status to read-only if the proxy is read-only
isReallyReadOnly = ((INHibernateProxy)proxy).HibernateLazyInitializer.ReadOnly;
}
}
if (isReallyReadOnly)
{
//no need to take a snapshot - this is a
//performance optimization, but not really
//important, except for entities with huge
//mutable property values
persistenceContext.SetEntryStatus(entityEntry, Status.ReadOnly);
}
else
{
//take a snapshot
TypeHelper.DeepCopy(hydratedState, persister.PropertyTypes, persister.PropertyUpdateability, hydratedState, session);
persistenceContext.SetEntryStatus(entityEntry, Status.Loaded);
}
persister.AfterInitialize(entity, entityEntry.LoadedWithLazyPropertiesUnfetched, session);
if (session.IsEventSource)
{
postLoadEvent.Entity = entity;
postLoadEvent.Id = id;
postLoadEvent.Persister = persister;
IPostLoadEventListener[] listeners = session.Listeners.PostLoadEventListeners;
for (int i = 0; i < listeners.Length; i++)
{
listeners[i].OnPostLoad(postLoadEvent);
}
}
if (log.IsDebugEnabled())
{
log.Debug("done materializing entity {0}", MessageHelper.InfoString(persister, id, session.Factory));
}
if (statsEnabled)
{
stopWath.Stop();
factory.StatisticsImplementor.LoadEntity(persister.EntityName, stopWath.Elapsed);
}
}
public IndexRemoveTask(QueryIndexManager indexManager, object key, CacheEntry value)
{
_key = key;
_entry = value;
_indexManager = indexManager;
}
/// <summary> /// Return true if the given <paramref name="key"/> matches the given <paramref name="entry"/>. /// </summary> protected abstract bool IsMatch(TKey key, CacheEntry entry);
private void LoadCache()
{
if( File.Exists( CachePath ) )
{
using( FileStream stream = new FileStream( CachePath, FileMode.Open, FileAccess.Read ) )
using( BinaryReader reader = new BinaryReader( stream ) )
{
try
{
int cacheSize = reader.ReadInt32();
assetDependencyCache = new Dictionary<string, CacheEntry>( cacheSize );
for( int i = 0; i < cacheSize; i++ )
{
string assetPath = reader.ReadString();
string hash = reader.ReadString();
int dependenciesLength = reader.ReadInt32();
string[] dependencies = new string[dependenciesLength];
long[] fileSizes = new long[dependenciesLength];
for( int j = 0; j < dependenciesLength; j++ )
{
dependencies[j] = reader.ReadString();
fileSizes[j] = reader.ReadInt64();
}
assetDependencyCache[assetPath] = new CacheEntry( hash, dependencies, fileSizes );
}
}
catch( Exception e )
{
assetDependencyCache = null;
Debug.LogException( e );
}
}
}
// Generate cache for all assets for the first time
if( assetDependencyCache == null )
{
assetDependencyCache = new Dictionary<string, CacheEntry>( 1024 * 8 );
string[] allAssets = AssetDatabase.GetAllAssetPaths();
if( allAssets.Length > 0 )
{
double startTime = EditorApplication.timeSinceStartup;
try
{
for( int i = 0; i < allAssets.Length; i++ )
{
if( i % 30 == 0 && EditorUtility.DisplayCancelableProgressBar( "Please wait...", "Generating cache for the first time", (float) i / allAssets.Length ) )
{
EditorUtility.ClearProgressBar();
Debug.LogWarning( "Initial cache generation cancelled, cache will be generated on the fly as more and more assets are searched." );
break;
}
AssetHasAnyReference( allAssets[i] );
}
EditorUtility.ClearProgressBar();
Debug.Log( "Cache generated in " + ( EditorApplication.timeSinceStartup - startTime ).ToString( "F2" ) + " seconds" );
Debug.Log( "You can always reset the cache by deleting " + Path.GetFullPath( CachePath ) );
SaveCache();
}
catch( Exception e )
{
EditorUtility.ClearProgressBar();
Debug.LogException( e );
}
}
}
}
private void AddToCache(string filename, BitmapEntry entry) {
_fromCache = false;
if (OptionCacheTotalEntries <= 0 || OptionCacheTotalSize <= 0 ||
entry.Size < OptionCacheMinSize || entry.Size > OptionCacheMaxSize) return;
var cache = Cache;
var lastIndex = cache.Count - 1;
lock (cache) {
var index = -1;
for (var i = lastIndex; i >= 0; i--) {
if (string.Equals(cache[i].Key, filename, OptionCacheStringComparison)) {
index = i;
break;
}
}
CacheEntry item;
if (index == -1) {
// item does not exist now, let’s add it
item = new CacheEntry {
Key = filename,
Value = entry
};
// if queue is full, remove the first entry to avoid re-creating
// array thing inside of the list
if (cache.Count == OptionCacheTotalEntries) {
if (OptionMarkCached) {
Logging.Debug($"total cached: {cache.Count} entries (capacity: {cache.Capacity})");
}
cache.RemoveAt(0);
}
cache.Add(item);
} else {
// item already exists, let’s update its value
item = cache[index];
item.Value = entry;
if (index < lastIndex) {
// and move it to the end of removal queue if needed
cache.RemoveAt(index);
cache.Add(item);
}
}
// remove old entries
var total = item.Value.Size;
for (var i = lastIndex - 1; i >= 0; i--) {
total += cache[i].Value.Size;
if (total > OptionCacheTotalSize) {
if (OptionMarkCached) {
Logging.Debug($"total cached size: {total / 1024d / 1024:F2} MB, let’s remove first {i + 1} image{(i > 0 ? "s" : "")}");
}
cache.RemoveRange(0, i + 1);
return;
}
}
if (OptionMarkCached) {
Logging.Debug($"total cached size: {total / 1024d / 1024:F2} MB, no need to remove anything");
}
}
}
private BindResult <T> BindProperties <T>(T target, bool requireAll = true, string prefix = null, bool preload = false, List <string> errors = null)
{
errors = errors ?? new List <string>();
prefix = prefix ?? _bindingPath;
foreach (var prop in typeof(T).GetProperties())
{
try
{
if (preload && prop.Name == nameof(Environment))
{
continue;
}
var readonlyProp = prop.GetSetMethod() is null;
var name = String.IsNullOrEmpty(prefix?.Trim()) ? prop.Name : $"{prefix}.{prop.Name}";
// No need to continue if the property is readonly and not part of a preload operation
if (readonlyProp && !preload)
{
continue;
}
if (prop.PropertyType.IsAbstract || prop.PropertyType.IsInterface)
{
continue;
}
var result = GetPropertyValue(prop, name, preload, requireAll);
if (!(result?.Result is null))
{
// When there is a preload and the value is not in the cache yet, do that here
if (preload && !_cache.ContainsKey(name))
{
_cache[name] = new CacheEntry(result.Result);
}
// Otherwise set the value of the property if it is not readonly
else if (!readonlyProp)
{
prop.SetValue(
target,
result.Result
);
}
}
if (result?.Errors?.Any() == true)
{
errors.AddRange(result.Errors);
}
}
catch (TargetInvocationException tie)
{
switch (tie.InnerException)
{
case KeyNotFoundException _:
errors.Add(prop.Name + " not found");
break;
case FormatException fe:
errors.Add("Can't parse " + prop.Name);
break;
default:
errors.Add(prop.Name + " failed," + tie.InnerException.Message);
break;
}
}
catch (Exception ex)
{
errors.Add(prop.Name + " failed, " + ex.Message);
}
}
return(new BindResult <T>(errors, target));
}
/// <summary>
/// Removes the object and key pair from the cache. The key is specified as parameter.
/// Moreover it take a removal reason and a boolean specifying if a notification should
/// be raised.
/// </summary>
/// <param name="key">key of the entry.</param>
/// <param name="ir"></param>
/// <param name="notify">boolean specifying to raise the event.</param>
/// <param name="lockId"></param>
/// <param name="accessType"></param>
/// <param name="operationContext"></param>
/// <param name="removalReason">reason for the removal.</param>
/// <returns>item value</returns>
public override CacheEntry Remove(object key, ItemRemoveReason ir, bool notify, object lockId, LockAccessType accessType, OperationContext operationContext)
{
CacheEntry retVal = Internal.Remove(key, ir, notify, lockId, accessType, operationContext);
return(retVal);
}
public virtual Hashtable GetQueryInfo(object key, object value)
{
Hashtable queryInfo = new Hashtable();
Hashtable queryIndex = new Hashtable();
Hashtable namedTagInfo = new Hashtable();
Hashtable namedTagsList = new Hashtable();
Hashtable tagInfo = new Hashtable();
ArrayList tagsList = new ArrayList();
CacheEntry entry = (CacheEntry)value;
if (entry.ObjectType == null)
{
return(queryInfo);
}
IQueryIndex index = (IQueryIndex)_indexMap[entry.ObjectType];
IndexInformation indexInformation = entry.IndexInfo;
lock (_indexMap.SyncRoot)
{
if (indexInformation != null)
{
if (_typeMap != null)
{
int handleId = _typeMap.GetHandleId(entry.ObjectType);
if (handleId > -1)
{
ArrayList attributes = _typeMap.GetAttribList(handleId);
ArrayList attributeValues = new ArrayList();
for (int i = 0; i < attributes.Count; i++)
{
foreach (IndexStoreInformation indexStoreInfo in indexInformation.IndexStoreInformations)
{
if (attributes[i].ToString() == indexStoreInfo.StoreName)
{
if (indexStoreInfo.IndexPosition == null)
{
attributeValues.Add(null);
}
else
{
object val = indexStoreInfo.IndexPosition.GetKey();
string objValue = null;
if (val is DateTime)
{
objValue = ((DateTime)val).Ticks.ToString();
}
else
{
objValue = val.ToString();
}
attributeValues.Add(objValue);
}
break;
}
}
}
queryIndex.Add(handleId, attributeValues);
queryInfo["query-info"] = queryIndex;
}
}
}
if (indexInformation != null)
{
foreach (IndexStoreInformation indexStoreinfo in indexInformation.IndexStoreInformations)
{
if (AttributeIndex.IsNamedTagKey(indexStoreinfo.StoreName))
{
if (indexStoreinfo.IndexPosition != null)
{
namedTagsList.Add(ConvertToNamedTag(indexStoreinfo.StoreName.ToString()), indexStoreinfo.IndexPosition.GetKey());
}
}
else if (indexStoreinfo.StoreName.Equals(TAG_INDEX_KEY))
{
if (indexStoreinfo.IndexPosition != null)
{
tagsList.Add(indexStoreinfo.IndexPosition.GetKey());
}
}
}
}
namedTagInfo["type"] = entry.ObjectType;
namedTagInfo["named-tags-list"] = namedTagsList;
queryInfo["named-tag-info"] = namedTagInfo;
tagInfo["type"] = entry.ObjectType;
tagInfo["tags-list"] = tagsList;
queryInfo["tag-info"] = tagInfo;
}
return(queryInfo);
}
/// <summary>
/// Extract a subset of the specified iterator to fit the filter's
/// parameters (i.e. page size and page number).
/// </summary>
/// <remarks>
/// The returned array is guaranteed to iterate exactly in the same
/// order as the original iterator.
/// </remarks>
/// <param name="iter">
/// An original entry iterator.
/// </param>
/// <returns>
/// An array of entries extracted accordingly to the filter
/// parameters
/// </returns>
public virtual object[] ExtractPage(IEnumerator iter)
{
int pageSize = PageSize;
IComparer comparer = Comparer;
object anchorTop = TopAnchor;
object anchorBottom = BottomAnchor;
var entries = new object[pageSize];
int entryIndex = 0;
if (comparer == null || anchorTop == null && anchorBottom == null)
{
int skip = Page * pageSize;
// THIS IS A HACK: reconsider
if (comparer == null && anchorTop is int)
{
skip = ((int)anchorTop);
}
while (iter.MoveNext())
{
object entry = iter.Current;
if (--skip >= 0)
{
continue;
}
entries[entryIndex] = entry;
if (++entryIndex == pageSize)
{
break;
}
}
if (entryIndex < pageSize)
{
// last page is not full
int size = entryIndex;
var array = new object[size];
if (size > 0)
{
Array.Copy(entries, 0, array, 0, size);
}
entries = array;
}
}
else
{
bool isHeading = anchorTop != null || anchorBottom == null;
bool isInclusive = anchorTop != null && anchorBottom != null;
bool skip = isHeading;
bool wrap = false;
var entryTop = new CacheEntry(null, anchorTop);
var entryBottom = new CacheEntry(null, anchorBottom);
while (iter.MoveNext())
{
var entry = (CacheEntry)iter.Current;
if (skip)
{
int compare = comparer.Compare(entry, entryTop);
skip = isInclusive ? (compare < 0) : (compare <= 0);
if (skip)
{
continue;
}
}
if (isHeading)
{
entries[entryIndex] = entry;
if (++entryIndex == pageSize)
{
break;
}
}
else
{
if (comparer.Compare(entry, entryBottom) >= 0)
{
break;
}
entries[entryIndex] = entry;
if (++entryIndex == pageSize)
{
wrap = true;
entryIndex = 0;
}
}
}
if (wrap)
{
var array = new object[pageSize];
Array.Copy(entries, entryIndex, array, 0, pageSize - entryIndex);
Array.Copy(entries, 0, array, pageSize - entryIndex, entryIndex);
entries = array;
}
else if (entryIndex < pageSize)
{
// last page is not full
int size = entryIndex;
var array = new object[size];
if (size > 0)
{
Array.Copy(entries, 0, array, 0, size);
}
entries = array;
}
}
return(entries);
}
/// <summary> Attempts to load the entity from the second-level cache. </summary>
/// <param name="event">The load event </param>
/// <param name="persister">The persister for the entity being requested for load </param>
/// <param name="options">The load options. </param>
/// <returns> The entity from the second-level cache, or null. </returns>
protected virtual object LoadFromSecondLevelCache(LoadEvent @event, IEntityPersister persister, LoadType options)
{
ISessionImplementor source = @event.Session;
bool useCache = persister.HasCache && source.CacheMode.HasFlag(CacheMode.Get) &&
@event.LockMode.LessThan(LockMode.Read);
if (!useCache)
{
return(null);
}
ISessionFactoryImplementor factory = source.Factory;
var batchSize = persister.GetBatchSize();
if (batchSize > 1 && persister.Cache.PreferMultipleGet())
{
// The first item in the array is the item that we want to load
var entityBatch =
source.PersistenceContext.BatchFetchQueue.GetEntityBatch(persister, @event.EntityId, batchSize, false);
// Ignore null values as the retrieved batch may contains them when there are not enough
// uninitialized entities in the queue
var keys = new List <CacheKey>(batchSize);
for (var i = 0; i < entityBatch.Length; i++)
{
var key = entityBatch[i];
if (key == null)
{
break;
}
keys.Add(source.GenerateCacheKey(key, persister.IdentifierType, persister.RootEntityName));
}
var cachedObjects = persister.Cache.GetMany(keys.ToArray(), source.Timestamp);
for (var i = 1; i < cachedObjects.Length; i++)
{
Assemble(
keys[i],
cachedObjects[i],
new LoadEvent(entityBatch[i], @event.EntityClassName, @event.LockMode, @event.Session),
false);
}
return(Assemble(keys[0], cachedObjects[0], @event, true));
}
var cacheKey = source.GenerateCacheKey(@event.EntityId, persister.IdentifierType, persister.RootEntityName);
var cachedObject = persister.Cache.Get(cacheKey, source.Timestamp);
return(Assemble(cacheKey, cachedObject, @event, true));
object Assemble(CacheKey ck, object ce, LoadEvent evt, bool alterStatistics)
{
if (factory.Statistics.IsStatisticsEnabled && alterStatistics)
{
if (ce == null)
{
factory.StatisticsImplementor.SecondLevelCacheMiss(persister.Cache.RegionName);
log.Debug("Entity cache miss: {0}", ck);
}
else
{
factory.StatisticsImplementor.SecondLevelCacheHit(persister.Cache.RegionName);
log.Debug("Entity cache hit: {0}", ck);
}
}
if (ce != null)
{
CacheEntry entry = (CacheEntry)persister.CacheEntryStructure.Destructure(ce, factory);
// Entity was found in second-level cache...
// NH: Different behavior (take a look to options.ExactPersister (NH-295))
if (!options.ExactPersister || persister.EntityMetamodel.SubclassEntityNames.Contains(entry.Subclass))
{
return(AssembleCacheEntry(entry, evt.EntityId, persister, evt));
}
}
return(null);
}
}
public QualityMessage GetValue(SolutionMessage message, Evaluator evaluate, ExtensionRegistry extensions)
{
var entry = new CacheEntry(message.ToString());
bool lockTaken = false;
bool waited = false;
try {
Monitor.Enter(cacheLock, ref lockTaken);
while (true)
{
LinkedListNode <CacheEntry> node;
if (index.TryGetValue(entry, out node))
{
list.Remove(node);
list.AddLast(node);
Hits++;
lockTaken = false;
Monitor.Exit(cacheLock);
OnChanged();
return(node.Value.GetMessage(extensions));
}
else
{
if (!waited && activeEvaluations.Contains(entry.Key))
{
while (activeEvaluations.Contains(entry.Key))
{
Monitor.Wait(cacheLock);
}
waited = true;
}
else
{
activeEvaluations.Add(entry.Key);
lockTaken = false;
Monitor.Exit(cacheLock);
OnChanged();
try {
entry.SetMessage(evaluate(message));
Monitor.Enter(cacheLock, ref lockTaken);
index[entry] = list.AddLast(entry);
Trim();
} finally {
if (!lockTaken)
{
Monitor.Enter(cacheLock, ref lockTaken);
}
activeEvaluations.Remove(entry.Key);
Monitor.PulseAll(cacheLock);
lockTaken = false;
Monitor.Exit(cacheLock);
}
OnChanged();
return(entry.GetMessage(extensions));
}
}
}
} finally {
if (lockTaken)
{
Monitor.Exit(cacheLock);
}
}
}
public virtual void AddToIndex(object key, object value, OperationContext operationContext)
{
CacheEntry entry = (CacheEntry)value;
Hashtable queryInfo = entry.QueryInfo["query-info"] as Hashtable;
if (queryInfo == null)
{
return;
}
lock (_indexMap.SyncRoot)
{
IDictionaryEnumerator queryInfoEnumerator = queryInfo.GetEnumerator();
while (queryInfoEnumerator.MoveNext())
{
int handleId = (int)queryInfoEnumerator.Key;
string type = _typeMap.GetTypeName(handleId);
if (_indexMap.Contains(type))
{
Hashtable indexAttribs = new Hashtable();
Hashtable metaInfoAttribs = new Hashtable();
ArrayList values = (ArrayList)queryInfoEnumerator.Value;
ArrayList attribList = _typeMap.GetAttribList(handleId);
for (int i = 0; i < attribList.Count; i++)
{
string attribute = attribList[i].ToString();
string val = _typeMap.GetAttributes(handleId)[attribList[i]] as string;
if (Common.Util.JavaClrTypeMapping.JavaToClr(val) != null)
{
val = Common.Util.JavaClrTypeMapping.JavaToClr(val);
}
Type t1 = Type.GetType(val, true, true);
object obj = null;
if (values[i] != null)
{
try
{
if (t1 == typeof(System.DateTime))
{
obj = new DateTime(Convert.ToInt64(values[i]));
}
else
{
obj = Convert.ChangeType(values[i], t1);
}
}
catch (Exception)
{
throw new System.FormatException("Cannot convert '" + values[i] + "' to " + t1.ToString());
}
indexAttribs.Add(attribute, obj);
}
else
{
indexAttribs.Add(attribute, null);
}
metaInfoAttribs.Add(attribute, obj);
}
MetaInformation metaInformation = new MetaInformation(metaInfoAttribs);
metaInformation.CacheKey = key as string;
metaInformation.Type = _typeMap.GetTypeName(handleId);
operationContext.Add(OperationContextFieldName.IndexMetaInfo, metaInformation);
entry.ObjectType = _typeMap.GetTypeName(handleId);
IQueryIndex index = (IQueryIndex)_indexMap[type];
long prevSize = index.IndexInMemorySize;
index.AddToIndex(key, new QueryItemContainer(entry, indexAttribs));
this._queryIndexMemorySize += index.IndexInMemorySize - prevSize;
}
}
}
}
/// <exception cref="WinrtCifs.Smb.SmbAuthException"></exception>
public virtual DfsReferral Resolve(string domain, string root, string path, NtlmPasswordAuthentication
auth)
{
lock (this)
{
DfsReferral dr = null;
long now = Runtime.CurrentTimeMillis();
if (Disabled || root.Equals("IPC$"))
{
return(null);
}
Hashtable domains = GetTrustedDomains(auth);
if (domains != null)
{
domain = domain.ToLower();
Hashtable roots = (Hashtable)domains.Get(domain);
if (roots != null)
{
SmbTransport trans = null;
root = root.ToLower();
CacheEntry links = (CacheEntry)roots.Get(root);
if (links != null && now > links.Expiration)
{
//Sharpen.Collections.Remove(roots, root);
roots.Remove(root);
links = null;
}
if (links == null)
{
if ((trans = GetDc(domain, auth)) == null)
{
return(null);
}
dr = GetReferral(trans, domain, root, path, auth);
if (dr != null)
{
int len = 1 + domain.Length + 1 + root.Length;
links = new CacheEntry(0L);
DfsReferral tmp = dr;
do
{
if (path == null)
{
// TODO: fix this
//tmp.map = links.map;
tmp.Key = "\\";
}
tmp.PathConsumed -= len;
tmp = tmp.Next;
}while (tmp != dr);
if (dr.Key != null)
{
links.Map.Put(dr.Key, dr);
}
roots.Put(root, links);
}
else
{
if (path == null)
{
roots.Put(root, FalseEntry);
}
}
}
else
{
if (links == FalseEntry)
{
links = null;
}
}
if (links != null)
{
string link = "\\";
dr = (DfsReferral)links.Map.Get(link);
if (dr != null && now > dr.Expiration)
{
//Sharpen.Collections.Remove(links.map, link);
links.Map.Remove(link);
dr = null;
}
if (dr == null)
{
if (trans == null)
{
if ((trans = GetDc(domain, auth)) == null)
{
return(null);
}
}
dr = GetReferral(trans, domain, root, path, auth);
if (dr != null)
{
dr.PathConsumed -= 1 + domain.Length + 1 + root.Length;
dr.Link = link;
links.Map.Put(link, dr);
}
}
}
}
}
if (dr == null && path != null)
{
if (Referrals != null && now > Referrals.Expiration)
{
Referrals = null;
}
if (Referrals == null)
{
Referrals = new CacheEntry(0);
}
string key = "\\" + domain + "\\" + root;
if (path.Equals("\\") == false)
{
key += path;
}
key = key.ToLower();
//ListIterator<object> iter = new ListIterator<object>(referrals.map.Keys.GetEnumerator(), 0);
foreach (var current in Referrals.Map.Keys)
{
string _key = (string)current;
int klen = _key.Length;
bool match = false;
if (klen == key.Length)
{
match = _key.Equals(key);
}
else
{
if (klen < key.Length)
{
match = _key.RegionMatches(false, 0, key, 0, klen) && key[klen] == '\\';
}
}
if (match)
{
dr = (DfsReferral)Referrals.Map.Get(_key);
}
}
}
return(dr);
}
}
private object AssembleCacheEntry(CacheEntry entry, object id, IEntityPersister persister, LoadEvent @event)
{
object optionalObject = @event.InstanceToLoad;
IEventSource session = @event.Session;
ISessionFactoryImplementor factory = session.Factory;
if (log.IsDebugEnabled())
{
log.Debug("assembling entity from second-level cache: {0}", MessageHelper.InfoString(persister, id, factory));
}
IEntityPersister subclassPersister = factory.GetEntityPersister(entry.Subclass);
object result = optionalObject ?? session.Instantiate(subclassPersister, id);
// make it circular-reference safe
EntityKey entityKey = session.GenerateEntityKey(id, subclassPersister);
TwoPhaseLoad.AddUninitializedCachedEntity(entityKey, result, subclassPersister, LockMode.None, entry.AreLazyPropertiesUnfetched, entry.Version, session);
IType[] types = subclassPersister.PropertyTypes;
object[] values = entry.Assemble(result, id, subclassPersister, session.Interceptor, session); // intializes result by side-effect
TypeHelper.DeepCopy(values, types, subclassPersister.PropertyUpdateability, values, session);
object version = Versioning.GetVersion(values, subclassPersister);
if (log.IsDebugEnabled())
{
log.Debug("Cached Version: {0}", version);
}
IPersistenceContext persistenceContext = session.PersistenceContext;
bool isReadOnly = session.DefaultReadOnly;
if (persister.IsMutable)
{
object proxy = persistenceContext.GetProxy(entityKey);
if (proxy != null)
{
// this is already a proxy for this impl
// only set the status to read-only if the proxy is read-only
isReadOnly = ((INHibernateProxy)proxy).HibernateLazyInitializer.ReadOnly;
}
}
else
{
isReadOnly = true;
}
persistenceContext.AddEntry(
result,
isReadOnly ? Status.ReadOnly : Status.Loaded,
values,
null,
id,
version,
LockMode.None,
true,
subclassPersister,
false,
entry.AreLazyPropertiesUnfetched);
subclassPersister.AfterInitialize(result, entry.AreLazyPropertiesUnfetched, session);
persistenceContext.InitializeNonLazyCollections();
// upgrade the lock if necessary:
//lock(result, lockMode);
//PostLoad is needed for EJB3
//TODO: reuse the PostLoadEvent...
PostLoadEvent postLoadEvent = new PostLoadEvent(session);
postLoadEvent.Entity = result;
postLoadEvent.Id = id;
postLoadEvent.Persister = persister;
IPostLoadEventListener[] listeners = session.Listeners.PostLoadEventListeners;
for (int i = 0; i < listeners.Length; i++)
{
listeners[i].OnPostLoad(postLoadEvent);
}
return(result);
}
public Windows8x(byte[] rawBytes, AppCompatCache.OperatingSystemVersion os, int controlSet)
{
Entries = new List <CacheEntry>();
var index = 128;
var signature = "00ts";
ControlSet = controlSet;
EntryCount = -1;
if (os == AppCompatCache.OperatingSystemVersion.Windows81_Windows2012R2)
{
signature = "10ts";
}
var position = 0;
while (index < rawBytes.Length)
{
try
{
var ce = new CacheEntry
{
Signature = Encoding.ASCII.GetString(rawBytes, index, 4)
};
if (ce.Signature != signature)
{
break;
}
index += 4;
// skip 4 unknown
index += 4;
var ceDataSize = BitConverter.ToUInt32(rawBytes, index);
index += 4;
ce.PathSize = BitConverter.ToUInt16(rawBytes, index);
index += 2;
ce.Path = Encoding.Unicode.GetString(rawBytes, index, ce.PathSize).Replace(@"\??\", "");
index += ce.PathSize;
var packageLen = BitConverter.ToUInt16(rawBytes, index);
index += 2;
//skip package data
index += packageLen;
// skip 4 unknown (insertion flags?)
ce.InsertFlags = (AppCompatCache.InsertFlag)BitConverter.ToInt32(rawBytes, index);
index += 4;
// skip 4 unknown (shim flags?)
index += 4;
ce.LastModifiedTimeUTC =
DateTimeOffset.FromFileTime(BitConverter.ToInt64(rawBytes, index)).ToUniversalTime();
if (ce.LastModifiedTimeUTC.Value.Year == 1601)
{
ce.LastModifiedTimeUTC = null;
}
index += 8;
ce.DataSize = BitConverter.ToInt32(rawBytes, index);
index += 4;
ce.Data = rawBytes.Skip(index).Take(ce.DataSize).ToArray();
index += ce.DataSize;
if ((ce.InsertFlags & AppCompatCache.InsertFlag.Executed) == AppCompatCache.InsertFlag.Executed)
{
ce.Executed = AppCompatCache.Execute.Yes;
}
else
{
ce.Executed = AppCompatCache.Execute.No;
}
ce.ControlSet = controlSet;
ce.CacheEntryPosition = position;
Entries.Add(ce);
position += 1;
}
catch (Exception ex)
{
Log.Error(ex, "Error parsing cache entry. Position: {Position} Index: {Index}, Error: {Message} ", position, index, ex.Message);
//TODO report this
//take what we can get
break;
}
}
}
/// <summary>
/// Serialize the example.
/// </summary>
/// <param name="example">The example to serialize.</param>
/// <param name="label">The label to be serialized.</param>
/// <param name="index">The optional index of the example, the <paramref name="label"/> should be attributed to.</param>
/// <returns>The serialized example.</returns>
/// <remarks>If <typeparamref name="TExample"/> is annotated using the Cachable attribute, examples are returned from cache.</remarks>
public VowpalWabbitExample Serialize(TExample example, ILabel label = null, int?index = null)
{
Contract.Requires(example != null);
Contract.Requires(index == null);
if (this.exampleCache == null || label != null)
{
using (var context = new VowpalWabbitMarshalContext(vw))
{
this.serializerFunc(context, example, label);
var vwExample = context.ExampleBuilder.CreateExample();
if (this.EnableStringExampleGeneration)
{
vwExample.VowpalWabbitString = context.ToString();
}
return(vwExample);
}
}
CacheEntry result;
if (this.exampleCache.TryGetValue(example, out result))
{
result.LastRecentUse = DateTime.UtcNow;
#if DEBUG
if (result.InUse)
{
throw new ArgumentException("Cached example already in use.");
}
#endif
}
else
{
VowpalWabbitExample nativeExample = null;
try
{
using (var context = new VowpalWabbitMarshalContext(this))
{
this.serializerFunc(context, example, label);
nativeExample = context.ExampleBuilder.CreateExample();
}
result = new CacheEntry
{
Example = nativeExample,
LastRecentUse = DateTime.UtcNow
};
this.exampleCache.Add(example, result);
#if DEBUG
this.reverseLookup.Add(result.Example, result);
#endif
}
catch (Exception e)
{
if (nativeExample != null)
{
nativeExample.Dispose();
}
throw e;
}
}
#if DEBUG
result.InUse = true;
#endif
// TODO: support Label != null here and update cached example using new label
return(result.Example);
}
public ReaderResultSet GetRecordSet(string readerId, int nextIndex, bool inproc, OperationContext context)
{
ReaderResultSet readerChunk = null;
IRecordSet partialRecordSet = null;
ReaderResultSet reader = null;
RecordRow row = null;
CacheEntry entry = null;
CompressedValueEntry cmpEntry = null;
int size = 0;
try
{
if (!string.IsNullOrEmpty(readerId))
{
if (_readers.ContainsKey(readerId))
{
reader = _readers[readerId];
}
}
if (reader != null)
{
if (nextIndex != 0 && reader.RecordSet.SubsetInfo.LastAccessedRowID == nextIndex)
{
reader.RecordSet.RemoveRows(reader.RecordSet.SubsetInfo.StartIndex, nextIndex - reader.RecordSet.SubsetInfo.StartIndex);
}
if (reader.RecordSet.RowCount > 0)
{
readerChunk = new ReaderResultSet();
reader.LastAccessTime = DateTime.Now;
partialRecordSet = new RecordSet(reader.RecordSet.GetColumnMetaData());
int chunkSize = reader.ChunkSize;
reader.RecordSet.SubsetInfo.StartIndex = nextIndex;
int nextRowID = nextIndex;
while (size <= chunkSize)
{
row = reader.RecordSet.GetRow(nextRowID++);
if (row == null)
{
break;
}
row = row.Clone() as RecordRow;
if (reader.GetData && !reader.IsGrouped)
{
entry = _context.CacheImpl.Get(row.GetColumnValue(QueryKeyWords.KeyColumn), context);
row.IsSurrogate = entry != null && entry.IsSurrogate;
if (entry != null && !entry.IsSurrogate)
{
if (inproc)
{
row.SetColumnValue(QueryKeyWords.ValueColumn, entry.Value);
}
else
{
cmpEntry = new CompressedValueEntry();
cmpEntry.Value = entry.Value;
if (cmpEntry.Value is CallbackEntry)
{
cmpEntry.Value = ((CallbackEntry)cmpEntry.Value).Value;
}
cmpEntry.Flag = ((CacheEntry)entry).Flag;
row.SetColumnValue(QueryKeyWords.ValueColumn, cmpEntry);
}
size += entry.Size;
}
if (entry != null)
{
if (entry.IsSurrogate)
{
size += 1024;
}
partialRecordSet.AddRow(row);
size += row.GetSize();
}
}
else
{
partialRecordSet.AddRow(row);
size += row.GetSize();
}
}
//Value column has been filled if getData is true
if (reader.GetData && !reader.IsGrouped)
{
reader.RecordSet.GetColumnMetaData()[QueryKeyWords.ValueColumn].IsFilled = true;
}
reader.RecordSet.SubsetInfo.LastAccessedRowID += partialRecordSet.RowCount;
readerChunk.RecordSet = partialRecordSet;
readerChunk.NextIndex = reader.RecordSet.SubsetInfo.LastAccessedRowID;
if (!inproc)
{
readerChunk.NodeAddress = GetReciepent();
}
readerChunk.OrderByArguments = reader.OrderByArguments;
readerChunk.IsGrouped = reader.IsGrouped;
readerChunk.ReaderID = reader.ReaderID;
}
else
{
DisposeReader(reader.ReaderID);
}
}
return(readerChunk);
}
catch (Exception ex)
{
if (ex is InvalidReaderException)
{
DisposeReader(reader.ReaderID);
}
throw;
}
}
private void AddChildrenRecursive(string directory, int depth, string[] entries)
{
for (int i = 0; i < entries.Length; i++)
{
string entry = entries[i];
if (string.IsNullOrEmpty(entry))
{
continue;
}
int instanceID = GetInstanceIDFromPath(entry);
string displayName = Path.GetFileNameWithoutExtension(entry);
TreeViewItem item = null;
if (!isSearching || textComparer.IndexOf(displayName, searchString, textCompareOptions) >= 0)
{
item = new TreeViewItem(instanceID, !isSearching ? depth : 0, displayName)
{
icon = AssetDatabase.GetCachedIcon(entry) as Texture2D
};
rows.Add(item);
}
if (Directory.Exists(entry))
{
if (isSearching || IsExpanded(instanceID))
{
string[] entries2;
if (FolderHasEntries(entry, out entries2))
{
AddChildrenRecursive(entry, depth + 1, entries2);
}
}
else if (FolderHasEntries(entry))
{
item.children = CreateChildListForCollapsedParent();
}
}
else
{
CacheEntry cacheEntry = GetCacheEntry(instanceID, entry);
int[] childAssets = cacheEntry.ChildIDs;
if (childAssets.Length > 0)
{
if (isSearching || IsExpanded(instanceID))
{
string[] childNames = cacheEntry.ChildNames;
Texture2D[] childThumbnails = cacheEntry.ChildThumbnails;
if (!isSearching)
{
for (int j = 0; j < childAssets.Length; j++)
{
rows.Add(new TreeViewItem(childAssets[j], depth + 1, childNames[j])
{
icon = childThumbnails[j]
});
}
}
else
{
for (int j = 0; j < childAssets.Length; j++)
{
if (textComparer.IndexOf(childNames[j], searchString, textCompareOptions) >= 0)
{
rows.Add(new TreeViewItem(childAssets[j], 0, childNames[j])
{
icon = childThumbnails[j]
});
}
}
}
}
else
{
item.children = CreateChildListForCollapsedParent();
}
}
}
}
}
public override void ResetLeasable()
{
_result = CacheInsResult.Success;
_entry = null;
}
