/// <summary> /// Creates a new instance of CachedResult. /// </summary> /// <param name="path">The path to the cached file.</param> /// <param name="updated">If the file was updated as a result of this request, true; otherwise, false.</param> /// <param name="state">The state of the cache for this file.</param> /// <param name="cachedUntil">The time the cache expires.</param> /// <param name="ex">The exception that prevented the file from being updated, if any.</param> public CacheResult(string path, bool updated, CacheState state, DateTime cachedUntil, Exception ex) { m_path = path; m_updated = updated; m_state = state; m_cachedUntil = cachedUntil; m_ex = ex; }
/// <summary> /// Initializes a new instance of the <see cref="CacheItem"/> class. /// </summary> /// <param name="extension">The file extension.</param> /// <param name="smallIcon">The small shell icon.</param> /// <param name="largeIcon">The large shell icon.</param> /// <param name="filetype">The shell file type.</param> /// <param name="state">The cache state of the item.</param> public CacheItem(string extension, Image smallIcon, Image largeIcon, string filetype, CacheState state) { Extension = extension; SmallIcon = smallIcon; LargeIcon = largeIcon; FileType = filetype; State = state; disposed = false; }
/// <summary> /// Initializes a new instance of the CacheItem class /// for use with a virtual item. /// </summary> /// <param name="guid">The guid of the ImageListViewItem.</param> /// <param name="key">The public key for the virtual item.</param> /// <param name="size">The size of the requested thumbnail.</param> /// <param name="image">The thumbnail image.</param> /// <param name="state">The cache state of the item.</param> public CacheItem(Guid guid, object key, Size size, Image image, CacheState state) : this(guid, key, size, image, state, UseEmbeddedThumbnails.Auto) { ; }
/// <summary> /// Creates a new <see cref="WebApiResponse" /> with a string as backing content. /// </summary> /// <param name="content">The content.</param> /// <param name="statusCode">The status code.</param> /// <param name="cacheState">The cache state.</param> /// <param name="responseHeaders">The response headers.</param> /// <exception cref="ArgumentNullException"><paramref name="content"/> is <see langword="null"/>.</exception> public WebApiResponse(string content, HttpStatusCode?statusCode, CacheState cacheState, IDictionary <string, string>?responseHeaders) : base(content, statusCode, cacheState, responseHeaders) { }
/// <summary> /// Inserts the given item without raising a selection changed event. /// </summary> /// <param name="index">Insertion index. If index is -1 the item is added to the end of the list.</param> /// <param name="item">The <see cref="ImageListViewItem"/> to add.</param> /// <param name="adaptor">The adaptor associated with this item.</param> /// <returns>true if the item was added; otherwise false.</returns> internal bool InsertInternal(int index, ImageListViewItem item, ImageListViewItemAdaptor adaptor) { if (mImageListView == null) { return(false); } // Check if the file already exists if (!string.IsNullOrEmpty(item.FileName) && !mImageListView.AllowDuplicateFileNames) { if (mItems.Exists(a => string.Compare(a.FileName, item.FileName, StringComparison.OrdinalIgnoreCase) == 0)) { return(false); } } item.owner = this; item.mAdaptor = adaptor; if (index == -1) { item.mIndex = mItems.Count; mItems.Add(item); } else { item.mIndex = index; for (int i = index; i < mItems.Count; i++) { mItems[i].mIndex++; } mItems.Insert(index, item); } lookUp.Add(item.Guid, item); collectionModified = true; item.mImageListView = mImageListView; // Create sub item texts for custom columns foreach (ImageListViewColumnHeader header in mImageListView.Columns) { if (header.Type == ColumnType.Custom) { item.AddSubItemText(header.Guid); } } // Add current thumbnail to cache if (item.clonedThumbnail != null) { mImageListView.thumbnailCache.Add(item.Guid, item.Adaptor, item.VirtualItemKey, mImageListView.ThumbnailSize, item.clonedThumbnail, mImageListView.UseEmbeddedThumbnails, mImageListView.AutoRotateThumbnails, (mImageListView.UseWIC == UseWIC.Auto || mImageListView.UseWIC == UseWIC.ThumbnailsOnly)); item.clonedThumbnail = null; } // Add to thumbnail cache if (mImageListView.CacheMode == CacheMode.Continuous) { mImageListView.thumbnailCache.Add(item.Guid, item.Adaptor, item.VirtualItemKey, mImageListView.ThumbnailSize, mImageListView.UseEmbeddedThumbnails, mImageListView.AutoRotateThumbnails, (mImageListView.UseWIC == UseWIC.Auto || mImageListView.UseWIC == UseWIC.ThumbnailsOnly)); } // Add to details cache mImageListView.metadataCache.Add(item.Guid, item.Adaptor, item.VirtualItemKey, (mImageListView.UseWIC == UseWIC.Auto || mImageListView.UseWIC == UseWIC.DetailsOnly)); // Add to shell info cache string extension = item.extension; if (!string.IsNullOrEmpty(extension)) { CacheState state = mImageListView.shellInfoCache.GetCacheState(extension); if (state == CacheState.Error && mImageListView.RetryOnError == true) { mImageListView.shellInfoCache.Remove(extension); mImageListView.shellInfoCache.Add(extension); } else if (state == CacheState.Unknown) { mImageListView.shellInfoCache.Add(extension); } } // Update groups if (mImageListView.GroupsVisible) { AddRemoveGroupItem(item.Index, true); } // Raise the add event mImageListView.OnItemCollectionChanged(new ItemCollectionChangedEventArgs(CollectionChangeAction.Add, item)); return(true); }
/// <summary> /// Initializes a new instance of the <see cref="CacheItem"/> class /// for use with a virtual item. /// </summary> /// <param name="guid">The guid of the ImageListViewItem.</param> /// <param name="size">The size of the requested thumbnail.</param> /// <param name="image">The thumbnail image.</param> /// <param name="rating">The rating of the item.</param> /// <param name="state">The cache state of the item.</param> /// <param name="useEmbeddedThumbnails">UseEmbeddedThumbnails property of the owner control.</param> /// <param name="autoRotate">AutoRotate property of the owner control.</param> /// <param name="useWIC">Whether to use WIC.</param> public CacheItem(Guid guid, Size size, Image image, ushort rating, CacheState state, UseEmbeddedThumbnails useEmbeddedThumbnails, bool autoRotate, bool useWIC) { Guid = guid; Size = size; Image = image; Rating = rating; State = state; UseEmbeddedThumbnails = useEmbeddedThumbnails; AutoRotate = autoRotate; UseWIC = useWIC; disposed = false; }
private int AcquireModify(Acquire rpc) { CacheHolder sender = (CacheHolder)rpc.Sender.UserState; rpc.Result = rpc.Argument; while (true) { CacheState cs = global.GetOrAdd(rpc.Argument.GlobalTableKey, (tabkeKeyNotUsed) => new CacheState()); lock (cs) { if (cs.AcquireStatePending == StateRemoved) { continue; } while (cs.AcquireStatePending != StateInvalid) { switch (cs.AcquireStatePending) { case StateShare: if (cs.Modify == sender) { logger.Debug("1 {0} {1} {2}", sender, rpc.Argument.State, cs); rpc.Result.State = StateInvalid; rpc.SendResultCode(AcquireModifyDeadLockFound); return(0); } break; case StateModify: if (cs.Modify == sender || cs.Share.Contains(sender)) { logger.Debug("2 {0} {1} {2}", sender, rpc.Argument.State, cs); rpc.Result.State = StateInvalid; rpc.SendResultCode(AcquireModifyDeadLockFound); return(0); } break; } logger.Debug("3 {0} {1} {2}", sender, rpc.Argument.State, cs); Monitor.Wait(cs); } cs.AcquireStatePending = StateModify; if (cs.Modify != null) { if (cs.Modify == sender) { logger.Debug("4 {0} {1} {2}", sender, rpc.Argument.State, cs); // 已经是Modify又申请,可能是sender异常关闭,又重启连上。 // 更新一下。应该是不需要的。 sender.Acquired[rpc.Argument.GlobalTableKey] = StateModify; rpc.SendResultCode(AcquireModifyAlreadyIsModify); cs.AcquireStatePending = StateInvalid; return(0); } int stateReduceResult = StateReduceException; Zeze.Util.Task.Run( () => { stateReduceResult = cs.Modify.Reduce(rpc.Argument.GlobalTableKey, StateInvalid); lock (cs) { Monitor.PulseAll(cs); } }, "GlobalCacheManager.AcquireModify.Reduce"); logger.Debug("5 {0} {1} {2}", sender, rpc.Argument.State, cs); Monitor.Wait(cs); switch (stateReduceResult) { case StateInvalid: cs.Modify.Acquired.TryRemove(rpc.Argument.GlobalTableKey, out var _); break; // reduce success default: // case StateReduceRpcTimeout: // case StateReduceException: // case StateReduceNetError: cs.AcquireStatePending = StateInvalid; Monitor.Pulse(cs); logger.Error("XXX 9 {0} {1} {2}", sender, rpc.Argument.State, cs); rpc.Result.State = StateInvalid; rpc.SendResultCode(AcquireModifyFaild); return(0); } cs.Modify = sender; sender.Acquired[rpc.Argument.GlobalTableKey] = StateModify; cs.AcquireStatePending = StateInvalid; Monitor.Pulse(cs); logger.Debug("6 {0} {1} {2}", sender, rpc.Argument.State, cs); rpc.SendResult(); return(0); } List <Util.KV <CacheHolder, Reduce> > reducePending = new List <Util.KV <CacheHolder, Reduce> >(); HashSet <CacheHolder> reduceSuccessed = new HashSet <CacheHolder>(); bool senderIsShare = false; // 先把降级请求全部发送给出去。 foreach (CacheHolder c in cs.Share) { if (c == sender) { senderIsShare = true; reduceSuccessed.Add(sender); continue; } Reduce reduce = c.ReduceWaitLater(rpc.Argument.GlobalTableKey, StateInvalid); if (null != reduce) { reducePending.Add(Util.KV.Create(c, reduce)); } else { // 网络错误不再认为成功。整个降级失败,要中断降级。 // 已经发出去的降级请求要等待并处理结果。后面处理。 break; } } Zeze.Util.Task.Run( () => { // 一个个等待是否成功。WaitAll 碰到错误不知道怎么处理的, // 应该也会等待所有任务结束(包括错误)。 foreach (var reduce in reducePending) { try { reduce.Value.Future.Task.Wait(); if (reduce.Value.Result.State == StateInvalid) { // 后面还有个成功的处理循环,但是那里可能包含sender, // 在这里更新吧。 reduce.Key.Acquired.TryRemove(rpc.Argument.GlobalTableKey, out var _); reduceSuccessed.Add(reduce.Key); } else { reduce.Key.SetError(); } } catch (Exception ex) { reduce.Key.SetError(); // 等待失败不再看作成功。 logger.Error(ex, "Reduce {0} {1} {2} {3}", sender, rpc.Argument.State, cs, reduce.Value.Argument); } } lock (cs) { // 需要唤醒等待任务结束的,但没法指定,只能全部唤醒。 Monitor.PulseAll(cs); } }, "GlobalCacheManager.AcquireModify.WaitReduce"); logger.Debug("7 {0} {1} {2}", sender, rpc.Argument.State, cs); Monitor.Wait(cs); // 移除成功的。 foreach (CacheHolder successed in reduceSuccessed) { cs.Share.Remove(successed); } // 如果前面降级发生中断(break),这里就不会为0。 if (cs.Share.Count == 0) { cs.Modify = sender; sender.Acquired[rpc.Argument.GlobalTableKey] = StateModify; cs.AcquireStatePending = StateInvalid; Monitor.Pulse(cs); // Pending 结束,唤醒一个进来就可以了。 logger.Debug("8 {0} {1} {2}", sender, rpc.Argument.State, cs); rpc.SendResult(); } else { // senderIsShare 在失败的时候,Acquired 没有变化,不需要更新。 // 失败了,要把原来是share的sender恢复。先这样吧。 if (senderIsShare) { cs.Share.Add(sender); } cs.AcquireStatePending = StateInvalid; Monitor.Pulse(cs); // Pending 结束,唤醒一个进来就可以了。 logger.Error("XXX 10 {0} {1} {2}", sender, rpc.Argument.State, cs); rpc.Result.State = StateInvalid; rpc.SendResultCode(AcquireModifyFaild); } // 很好,网络失败不再看成成功,发现除了加break, // 其他处理已经能包容这个改动,都不用动。 return(0); } } }
private void RebuildStatusCacheIfNeeded(bool ignoreBackoff) { bool needToRebuild = false; DateTime now; lock (this.cacheFileLock) { CacheState cacheState = this.cacheState; now = DateTime.UtcNow; if (cacheState == CacheState.Clean) { this.context.Tracer.RelatedInfo("GitStatusCache.RebuildStatusCacheIfNeeded: Status Cache up-to-date."); } else if (!this.TryDeleteStatusCacheFile()) { // The cache is dirty, but we failed to delete the previous on disk cache. // Do not rebuild the cache this time. Wait for the next invalidation // to cause the thread to run again, or the on-disk cache will be deleted // if a status command is run. } else if (!ignoreBackoff && (now - this.lastInvalidationTime) < this.backoffTime) { // The approriate backoff time has not elapsed yet, // If this is the 1st time we are delaying the background // status scan (indicated by the initialDelayTime being set to // DateTime.MinValue), mark the current time. We can then track // how long the scan was delayed for. if (this.initialDelayTime == DateTime.MinValue) { this.initialDelayTime = now; } // Signal the background thread to run again, so it // can check if the backoff time has elapsed and it should // rebuild the status cache. this.wakeUpThread.Set(); } else { // The cache is dirty, and we succeeded in deleting the previous on disk cache and the minimum // backoff time has passed, so now we can rebuild the status cache. needToRebuild = true; } } if (needToRebuild) { if (this.initialDelayTime > DateTime.MinValue) { this.context.Tracer.RelatedInfo("GitStatusCache.RebuildStatusCacheIfNeeded: Generating new Status Cache... Status scan was delayed for: {0:0.##}s", (now - this.initialDelayTime).TotalSeconds); } else { this.context.Tracer.RelatedInfo("GitStatusCache.RebuildStatusCacheIfNeeded: Generating new Status Cache..."); } this.statistics.RecordBackgroundStatusScanRun(); bool rebuildStatusCacheSucceeded = this.TryRebuildStatusCache(); this.context.Tracer.RelatedInfo("GitStatusCache.RebuildStatusCacheIfNeeded: Done generating status. Cache is now: {0}", this.cacheState); this.initialDelayTime = DateTime.MinValue; } }
/// <summary> /// Creates a new <see cref="HttpResponseStream" />. /// </summary> /// <param name="contentStream">The content stream.</param> /// <param name="statusCode">The status code.</param> /// <param name="cacheState">The cache state.</param> /// <param name="requestHeaders">The original headers that were used in the web request.</param> /// <param name="responseHeaders">The response headers.</param> /// <exception cref="ArgumentNullException"><paramref name="contentStream"/> is <see langword="null"/>.</exception> public HttpResponseStream(Stream contentStream, HttpStatusCode?statusCode, CacheState cacheState, IEnumerable <KeyValuePair <string, string> >?requestHeaders, IEnumerable <KeyValuePair <string, string> >?responseHeaders) : this(contentStream, statusCode, cacheState, requestHeaders?.ShallowCopy(), responseHeaders?.ShallowCopy()) { }
private CacheState CompareState( CacheState a, CacheState b ) { if ( a == CacheState.Invalid || b == CacheState.Invalid ) //任何一个状态无效则无效 return CacheState.Invalid; else if ( a == CacheState.NearInvalid || b == CacheState.NearInvalid ) //在没有无效状态的前提下,有接近无效状态则接近无效 return CacheState.NearInvalid; else if ( a == CacheState.Valid && b == CacheState.Valid ) //只有两个状态都有效的时候才是有效的 return CacheState.Valid; else //无法识别的状态都是无效 return CacheState.Invalid; }
public CacheUsing removeCache() { this.cacheController = CacheState.Remove; return(this); }
/// <summary> /// Creates a new <see cref="HttpResponseStream" />. /// </summary> /// <param name="contentStream">The content stream.</param> /// <param name="cacheState">The cache state.</param> /// <exception cref="ArgumentNullException"><paramref name="contentStream"/> is <see langword="null"/>.</exception> public HttpResponseStream(Stream contentStream, CacheState cacheState) : this(contentStream, null, cacheState, null, null) { }
public CacheUsing refurbishCache(bool isRefubish) { this.cacheController = (isRefubish ? CacheState.Refurbish : CacheState.Using); return(this); }
public CacheUsing refurbishCache() { this.cacheController = CacheState.Refurbish; return(this); }
private Object cacheCondition; //Fun1<Boolean,T> //#endregion //#region ICacheUsing<Q> 成员 public CacheUsing usingCache(bool isCache) { this.cacheController = (isCache ? CacheState.Using : CacheState.NonUsing); return(this); }
/// <summary> /// Initializes a new instance of the CacheItem class. /// </summary> /// <param name="guid">The guid of the ImageListViewItem.</param> /// <param name="filename">The file system path to the image file.</param> /// <param name="size">The size of the requested thumbnail.</param> /// <param name="image">The thumbnail image.</param> /// <param name="state">The cache state of the item.</param> /// <param name="useEmbeddedThumbnails">UseEmbeddedThumbnails property of the owner control.</param> public CacheItem(Guid guid, string filename, Size size, Image image, CacheState state, UseEmbeddedThumbnails useEmbeddedThumbnails) { mGuid = guid; mFileName = filename; mSize = size; mImage = image; mState = state; mUseEmbeddedThumbnails = useEmbeddedThumbnails; mIsVirtualItem = false; disposed = false; }
public DocumentCache(CacheState state, XElement document) { State = state; Document = document; }
public override CacheState GetCacheState() { if ( _state == CacheState.Invalid ) return CacheState.Invalid; foreach ( var item in _items ) { _state = CompareState( _state, item.GetCacheState() ); if ( _state == CacheState.Invalid ) return CacheState.Invalid; } return _state; }
/// <summary> /// Gets an image from the cache manager. /// If the thumbnail image is not cached, it will be /// added to the cache queue and DefaultImage of the owner image list view will /// be returned. If the thumbnail could not be cached ErrorImage of the owner /// image list view will be returned. /// </summary> /// <param name="imageType">Type of cached image to return.</param> /// <returns>Requested thumbnail or icon.</returns> public Image GetCachedImage(CachedImageType imageType) { if (mImageListView == null) { throw new InvalidOperationException("Owner control is null."); } string iconPath = null; if (imageType == CachedImageType.SmallIcon || imageType == CachedImageType.LargeIcon) { if (string.IsNullOrEmpty(iconPath)) { return(mImageListView.DefaultImage); } CacheState state = mImageListView.shellInfoCache.GetCacheState(iconPath); if (state == CacheState.Cached) { if (imageType == CachedImageType.SmallIcon) { return(mImageListView.shellInfoCache.GetSmallIcon(iconPath)); } else { return(mImageListView.shellInfoCache.GetLargeIcon(iconPath)); } } else if (state == CacheState.Error) { if (mImageListView.RetryOnError) { mImageListView.shellInfoCache.Remove(iconPath); mImageListView.shellInfoCache.Add(iconPath); } return(mImageListView.ErrorImage); } else { mImageListView.shellInfoCache.Add(iconPath); return(mImageListView.DefaultImage); } } else { Image img = null; CacheState state = ThumbnailCacheState; if (state == CacheState.Error) { if (mImageListView.ShellIconFallback && !string.IsNullOrEmpty(iconPath)) { CacheState iconstate = mImageListView.shellInfoCache.GetCacheState(iconPath); if (iconstate == CacheState.Cached) { if (mImageListView.ThumbnailSize.Width > 32 && mImageListView.ThumbnailSize.Height > 32) { img = mImageListView.shellInfoCache.GetLargeIcon(iconPath); } else { img = mImageListView.shellInfoCache.GetSmallIcon(iconPath); } } else if (iconstate == CacheState.Error) { if (mImageListView.RetryOnError) { mImageListView.shellInfoCache.Remove(iconPath); mImageListView.shellInfoCache.Add(iconPath); } } else { mImageListView.shellInfoCache.Add(iconPath); } } if (img == null) { img = mImageListView.ErrorImage; } return(img); } img = mImageListView.thumbnailCache.GetImage(Guid, mAdaptor, mVirtualItemKey, mImageListView.ThumbnailSize, mImageListView.UseEmbeddedThumbnails, mImageListView.AutoRotateThumbnails, mImageListView.UseWIC == UseWIC.Auto || mImageListView.UseWIC == UseWIC.ThumbnailsOnly, false); if (state == CacheState.Cached) { return(img); } mImageListView.thumbnailCache.Add(Guid, mAdaptor, mVirtualItemKey, mImageListView.ThumbnailSize, mImageListView.UseEmbeddedThumbnails, mImageListView.AutoRotateThumbnails, (mImageListView.UseWIC == UseWIC.Auto || mImageListView.UseWIC == UseWIC.ThumbnailsOnly)); if (img == null && string.IsNullOrEmpty(iconPath)) { return(mImageListView.DefaultImage); } if (img == null && mImageListView.ShellIconFallback && mImageListView.ThumbnailSize.Width > 16 && mImageListView.ThumbnailSize.Height > 16) { img = mImageListView.shellInfoCache.GetLargeIcon(iconPath); } if (img == null && mImageListView.ShellIconFallback) { img = mImageListView.shellInfoCache.GetSmallIcon(iconPath); } if (img == null) { img = mImageListView.DefaultImage; } return(img); } }
private int AcquireShare(Acquire rpc) { CacheHolder sender = (CacheHolder)rpc.Sender.UserState; rpc.Result = rpc.Argument; while (true) { CacheState cs = global.GetOrAdd(rpc.Argument.GlobalTableKey, (tabkeKeyNotUsed) => new CacheState()); lock (cs) { if (cs.AcquireStatePending == StateRemoved) { continue; } while (cs.AcquireStatePending != StateInvalid) { switch (cs.AcquireStatePending) { case StateShare: if (cs.Modify == sender) { logger.Debug("1 {0} {1} {2}", sender, rpc.Argument.State, cs); rpc.Result.State = StateInvalid; rpc.SendResultCode(AcquireShareDeadLockFound); return(0); } break; case StateModify: if (cs.Modify == sender || cs.Share.Contains(sender)) { logger.Debug("2 {0} {1} {2}", sender, rpc.Argument.State, cs); rpc.Result.State = StateInvalid; rpc.SendResultCode(AcquireShareDeadLockFound); return(0); } break; } logger.Debug("3 {0} {1} {2}", sender, rpc.Argument.State, cs); Monitor.Wait(cs); } cs.AcquireStatePending = StateShare; if (cs.Modify != null) { if (cs.Modify == sender) { cs.AcquireStatePending = StateInvalid; logger.Debug("4 {0} {1} {2}", sender, rpc.Argument.State, cs); rpc.Result.State = StateModify; // 已经是Modify又申请,可能是sender异常关闭, // 又重启连上。更新一下。应该是不需要的。 sender.Acquired[rpc.Argument.GlobalTableKey] = StateModify; rpc.SendResultCode(AcquireShareAlreadyIsModify); return(0); } int stateReduceResult = StateReduceException; Zeze.Util.Task.Run( () => { stateReduceResult = cs.Modify.Reduce(rpc.Argument.GlobalTableKey, StateShare); lock (cs) { Monitor.PulseAll(cs); } }, "GlobalCacheManager.AcquireShare.Reduce"); logger.Debug("5 {0} {1} {2}", sender, rpc.Argument.State, cs); Monitor.Wait(cs); switch (stateReduceResult) { case StateShare: cs.Modify.Acquired[rpc.Argument.GlobalTableKey] = StateShare; cs.Share.Add(cs.Modify); // 降级成功,有可能降到 Invalid,此时就不需要加入 Share 了。 break; default: // 包含协议返回错误的值的情况。 // case StateReduceRpcTimeout: // case StateReduceException: // case StateReduceNetError: cs.AcquireStatePending = StateInvalid; Monitor.Pulse(cs); logger.Error("XXX 8 {0} {1} {2}", sender, rpc.Argument.State, cs); rpc.Result.State = StateInvalid; rpc.SendResultCode(AcquireShareFaild); return(0); } cs.Modify = null; sender.Acquired[rpc.Argument.GlobalTableKey] = StateShare; cs.Share.Add(sender); cs.AcquireStatePending = StateInvalid; Monitor.Pulse(cs); logger.Debug("6 {0} {1} {2}", sender, rpc.Argument.State, cs); rpc.SendResult(); return(0); } sender.Acquired[rpc.Argument.GlobalTableKey] = StateShare; cs.Share.Add(sender); cs.AcquireStatePending = StateInvalid; logger.Debug("7 {0} {1} {2}", sender, rpc.Argument.State, cs); rpc.SendResult(); return(0); } } }
/// <summary> /// Invalidate the status cache. Does not cause the cache to refresh /// If caller also wants to signal the refresh, they must call /// <see cref="RefreshAsynchronously" or cref="RefreshAndWait"/>. /// </summary> public virtual void Invalidate() { this.lastInvalidationTime = DateTime.UtcNow; this.cacheState = CacheState.Dirty; }
public void PassesCacheState(CacheState cacheState) { var response = new HttpResponseInfo(HttpStatusCode.OK, cacheState, null); response.CacheState.Should().Be(cacheState); }
/// <summary> /// Creates a new instance of CachedResult. /// </summary> /// <param name="path">The path to the cached file.</param> /// <param name="updated">If the file was updated as a result of this request, true; otherwise, false.</param> /// <param name="state">The state of the cache for this file.</param> /// <param name="cachedUntil">The time the cache expires.</param> public CacheResult(string path, bool updated, CacheState state, DateTime cachedUntil) : this(path, updated, state, cachedUntil, null) { }
/// <summary> /// Rebuild the status cache. This will run the background status to /// generate status results, and update the serialized status cache /// file. /// </summary> private bool TryRebuildStatusCache() { this.context.FileSystem.CreateDirectory(this.context.Enlistment.GitStatusCacheFolder); // The status cache is regenerated on mount. This means that even if the write to temp file // and rename operation doesn't complete (due to a system crash), and there is a torn write, // GVFS is still protected because a new status cache file will be generated on mount. string tmpStatusFilePath = Path.Combine(this.context.Enlistment.GitStatusCacheFolder, Path.GetRandomFileName() + "_status.tmp"); GitProcess.Result statusResult = null; // Do not modify this block unless you completely understand the comments and code within { // We MUST set the state to Rebuilding _immediately before_ we call the `git status` command. That allows us to // check afterwards if anything happened during the status command that should invalidate the cache, and we // can discard its results if that happens. this.cacheState = CacheState.Rebuilding; GitProcess git = this.context.Enlistment.CreateGitProcess(); statusResult = git.SerializeStatus( allowObjectDownloads: true, serializePath: tmpStatusFilePath); } bool rebuildSucceeded = false; if (!statusResult.HasErrors) { lock (this.cacheFileLock) { // Only update the cache if our state is still Rebuilding. Otherwise, this indicates that another call // to Invalidate came in, and moved the state back to Dirty. if (this.cacheState == CacheState.Rebuilding) { rebuildSucceeded = this.MoveCacheFileToFinalLocation(tmpStatusFilePath); if (rebuildSucceeded) { // We have to check the state once again, because it could have been invalidated while we were // copying the file in the previous step. Here we do it as a CompareExchange to minimize any further races. if (Interlocked.CompareExchange(ref this.cacheState, CacheState.Clean, CacheState.Rebuilding) != CacheState.Rebuilding) { // We did not succeed in setting the state to Clean. Note that we have already overwritten the on disk cache, // but all users of the cache file first check the cacheState, and since the cacheState is not Clean, no one // should ever read it. rebuildSucceeded = false; } } if (!rebuildSucceeded) { this.cacheState = CacheState.Dirty; } } } if (!rebuildSucceeded) { try { this.context.FileSystem.DeleteFile(tmpStatusFilePath); } catch (Exception ex) when(ex is IOException || ex is UnauthorizedAccessException) { EventMetadata metadata = new EventMetadata(); metadata.Add("Area", EtwArea); metadata.Add("Exception", ex.ToString()); this.context.Tracer.RelatedError( metadata, string.Format("GitStatusCache is unable to delete temporary status cache file at {0}.", tmpStatusFilePath)); } } } else { this.statistics.RecordBackgroundStatusScanError(); this.context.Tracer.RelatedInfo("GitStatusCache.TryRebuildStatusCache: Error generating status: {0}", statusResult.Errors); } return(rebuildSucceeded); }
/// <summary> /// Creates a new <see cref="WebApiResponse" /> with a string as backing content. /// </summary> /// <param name="content">The content.</param> /// <param name="statusCode">The status code.</param> /// <param name="cacheState">The cache state.</param> /// <param name="responseHeaders">The response headers.</param> /// <exception cref="ArgumentNullException"><paramref name="content"/> is <see langword="null"/>.</exception> public WebApiResponse(string content, HttpStatusCode?statusCode, CacheState cacheState, IEnumerable <KeyValuePair <string, string> >?responseHeaders) : base(content, statusCode, cacheState, responseHeaders) { }
public PlcCacheResult(CacheState state, int getpos, int savepos) { this.state = state; this.savepos = savepos; this.getpos = getpos; }
/// <summary> /// Initializes a new instance of the CacheItem class /// for use with a virtual item. /// </summary> /// <param name="guid">The guid of the ImageListViewItem.</param> /// <param name="key">The public key for the virtual item.</param> /// <param name="size">The size of the requested thumbnail.</param> /// <param name="image">The thumbnail image.</param> /// <param name="state">The cache state of the item.</param> /// <param name="useEmbeddedThumbnails">UseEmbeddedThumbnails property of the owner control.</param> public CacheItem(Guid guid, object key, Size size, Image image, CacheState state, UseEmbeddedThumbnails useEmbeddedThumbnails) { mGuid = guid; mVirtualItemKey = key; mFileName = string.Empty; mSize = size; mImage = image; mState = state; mUseEmbeddedThumbnails = useEmbeddedThumbnails; mIsVirtualItem = true; disposed = false; }
public CachedQualityNicoVideoListItemViewModel(NicoVideoCacheRequest req, VideoCacheManager cacheManager) { _Request = req; Quality = _Request.Quality; var firstCacheState = _Request.ToCacheState(); if (firstCacheState != NicoVideoCacheState.Cached) { CacheState = Observable.FromEventPattern <VideoCacheStateChangedEventArgs>( (x) => cacheManager.VideoCacheStateChanged += x, (x) => cacheManager.VideoCacheStateChanged -= x ) .Where(x => x.EventArgs.Request.RawVideoId == _Request.RawVideoId && x.EventArgs.Request.Quality == _Request.Quality) .Select(x => x.EventArgs.CacheState) .ObserveOnUIDispatcher() .ToReadOnlyReactiveProperty(firstCacheState) .AddTo(_CompositeDisposable); CacheState.Subscribe(x => { if (x == NicoVideoCacheState.Downloading) { var _cacheManager = App.Current.Container.Resolve <VideoCacheManager>(); float firstProgressParcent = 0.0f; if (_Request is NicoVideoCacheProgress) { var prog = (_Request as NicoVideoCacheProgress).DownloadOperation.Progress; if (prog.TotalBytesToReceive > 0) { firstProgressParcent = (float)Math.Round((prog.BytesReceived / (float)prog.TotalBytesToReceive) * 100, 1); } } ProgressPercent = Observable.FromEventPattern <NicoVideoCacheProgress>( (handler) => _cacheManager.DownloadProgress += handler, (handler) => _cacheManager.DownloadProgress -= handler ) .ObserveOnUIDispatcher() .Where(y => y.EventArgs.RawVideoId == _Request.RawVideoId && y.EventArgs.Quality == _Request.Quality) .Select(y => { var prog = y.EventArgs.DownloadOperation.Progress; if (prog.TotalBytesToReceive > 0) { return((float)Math.Round((prog.BytesReceived / (float)prog.TotalBytesToReceive) * 100, 1)); } else { return(0.0f); } }) .ToReactiveProperty(firstProgressParcent); RaisePropertyChanged(nameof(ProgressPercent)); } else { ProgressPercent?.Dispose(); ProgressPercent = null; RaisePropertyChanged(nameof(ProgressPercent)); } }) .AddTo(_CompositeDisposable); IsCacheDownloading = CacheState.Select(x => x == NicoVideoCacheState.Downloading) .ToReadOnlyReactiveProperty() .AddTo(_CompositeDisposable); } else { CacheState = new ReactiveProperty <NicoVideoCacheState>(NicoVideoCacheState.Cached); IsCacheDownloading = new ReactiveProperty <bool>(false); ProgressPercent = new ReactiveProperty <float>(0.0f); } IsCached = CacheState.Select(x => x == NicoVideoCacheState.Cached) .ToReadOnlyReactivePropertySlim() .AddTo(_CompositeDisposable); }
/// <summary> /// Initializes a new instance of the CacheItem class. /// </summary> /// <param name="guid">The guid of the ImageListViewItem.</param> /// <param name="filename">The file system path to the image file.</param> /// <param name="size">The size of the requested thumbnail.</param> /// <param name="image">The thumbnail image.</param> /// <param name="state">The cache state of the item.</param> public CacheItem(Guid guid, string filename, Size size, Image image, CacheState state) : this(guid, filename, size, image, state, UseEmbeddedThumbnails.Auto) { ; }
/// <summary> /// Creates a new <see cref="WebApiResponse" /> with a string as backing content. /// </summary> /// <param name="content">The content.</param> /// <param name="cacheState">The cache state.</param> /// <exception cref="ArgumentNullException"><paramref name="content"/> is <see langword="null"/>.</exception> public WebApiResponse(string content, CacheState cacheState) : base(content, null, cacheState, null) { }