コード例 #1
0
		public bool IsUpToDate (string path, Filter filter)
		{
			return IsUpToDate (path, filter, DateTime.MaxValue);
		}
コード例 #2
0
		// To be used if the last_write_time to use for comparison is not the
		// one obtained from path
		public bool IsUpToDate (string path, Filter filter, DateTime last_write_time)
		{
			FileAttributes attr;

			attr = Read (path);

			// If there are no attributes set on the file, there is no
			// way that we can be up-to-date.
			// Also, if attribute has no filter information, try once
			// again.
			if (attr == null)
				return false;

			// Note that when filter is set to null, we ignore
			// any existing filter data.  That might not be the
			// expected behavior...
			if (filter != null) {

				if (! attr.HasFilterInfo)
					return false;

				if (attr.FilterName != filter.Name)
					return false;
				
				// FIXME: Obviously we want to reindex if
				// attr.FilterVersion < filter.Version.
				// But what if the filter we would use is older
				// than the one that was previously used?
				if (attr.FilterVersion != filter.Version)
					return false;
			} 

			if (last_write_time == DateTime.MaxValue)
				return (attr.LastWriteTime >= FileSystem.GetLastWriteTimeUtc (path));
			else
				return (attr.LastWriteTime >= last_write_time);
		}
コード例 #3
0
ファイル: FilterFactory.cs プロジェクト: zweib730/beagrep
		static public bool FilterIndexable (Indexable indexable, out Filter filter)
		{
			return FilterIndexable (indexable, null, out filter);
		}
コード例 #4
0
ファイル: FilterFactory.cs プロジェクト: zweib730/beagrep
		/* Returns false if content can't/needn't be indexed.
		 * If AlreadyFiltered, then we don't return a filter but return true.
		 */
		static public bool FilterIndexable (Indexable indexable, TextCache text_cache, out Filter filter)
		{
			filter = null;
			ICollection filters = null;

			if (indexable.Filtering == IndexableFiltering.AlreadyFiltered)
				return true;

			if (! ShouldWeFilterThis (indexable))
				return false;

			string path = null;

			// First, figure out which filter we should use to deal with
			// the indexable.

			// If a specific mime type is specified, try to index as that type.
			if (indexable.MimeType != null)
				filters = CreateFiltersFromMimeType (indexable.MimeType);

			if (indexable.ContentUri.IsFile) {
				path = indexable.ContentUri.LocalPath;

				// Otherwise, set the mime type for a directory,
				// or sniff it from the file.
				if (indexable.MimeType == null) {
					if (Directory.Exists (path)) {
						indexable.MimeType = "inode/directory";
						indexable.NoContent = true;
					} else if (File.Exists (path)) {
						indexable.MimeType = XdgMime.GetMimeType (path);
					} else {
						Log.Warn ("Unable to filter {0}.  {1} not found.", indexable.DisplayUri, path);
						return false;
					}
				}

				// Set the timestamp to the last write time, if it isn't
				// set by the backend.
				if (! indexable.ValidTimestamp && indexable.IsNonTransient)
					indexable.Timestamp = FileSystem.GetLastWriteTimeUtc (path);

				// Check the timestamp to make sure the file hasn't
				// disappeared from underneath us.
				if (! FileSystem.ExistsByDateTime (indexable.Timestamp)) {
					Log.Warn ("Unable to filter {0}.  {1} appears to have disappeared from underneath us", indexable.DisplayUri, path);
					return false;
				}

				if (filters == null || filters.Count == 0) {
					filters = CreateFiltersFromIndexable (indexable);
				}
			}

			// We don't know how to filter this, so there is nothing else to do.
			if (filters.Count == 0) {
				if (! indexable.NoContent)
					Logger.Log.Debug ("No filter for {0} ({1}) [{2}]", indexable.DisplayUri, path, indexable.MimeType);

				return false;
			}

			foreach (Filter candidate_filter in filters) {
				if (Debug)
					Logger.Log.Debug ("Testing filter: {0}", candidate_filter);
				
				// Hook up the snippet writer.
				if (candidate_filter.SnippetMode && text_cache != null) {
					if (candidate_filter.OriginalIsText && indexable.IsNonTransient) {
						text_cache.MarkAsSelfCached (indexable.Uri);
					} else if (indexable.CacheContent) {
						TextWriter writer = text_cache.GetWriter (indexable.Uri);
						candidate_filter.AttachSnippetWriter (writer);
					}
				}

				// Set the indexable on the filter.
				candidate_filter.Indexable = indexable;

				// Open the filter, copy the file's properties to the indexable,
				// and hook up the TextReaders.

				bool successful_open = false;
				TextReader text_reader;
				Stream binary_stream;

				if (path != null)
					successful_open = candidate_filter.Open (path);
				else if ((text_reader = indexable.GetTextReader ()) != null)
					successful_open = candidate_filter.Open (text_reader);
				else if ((binary_stream = indexable.GetBinaryStream ()) != null)
					successful_open = candidate_filter.Open (binary_stream);
					
				if (successful_open) {
					// Set FileType
					indexable.AddProperty (Property.NewKeyword ("beagrep:FileType", candidate_filter.FileType));

					indexable.SetTextReader (candidate_filter.GetTextReader ());
					indexable.SetHotTextReader (candidate_filter.GetHotTextReader ());

					if (Debug)
						Logger.Log.Debug ("Successfully filtered {0} with {1}", path, candidate_filter);

					filter = candidate_filter;
					return true;
				} else {
					Log.Warn ("Error in filtering {0} with {1}, falling back", path, candidate_filter);
					candidate_filter.Cleanup ();
				}
			}

			if (Debug)
				Logger.Log.Debug ("None of the matching filters could process the file: {0}", path);

			return false;
		}
コード例 #5
0
		///////////////////////////////////////////////////////////////////////////

		// Convenience functions

		public bool IsUpToDate (string path, Filter filter)
		{
			return FileAttributesStore.IsUpToDate (path, filter);
		}
コード例 #6
0
			public void Cleanup ()
			{
				Filter.Cleanup ();
				Filter.CleanGeneratedIndexables ();
				Indexable.Cleanup ();
				Filter = null;
				Indexable = null;
				if (PersistentPropDocs != null)
					PersistentPropDocs.Clear ();
			}
コード例 #7
0
			public Hashtable PersistentPropDocs; // Contains the persistent properties for itself and children

			public DeferredInfo (Indexable indexable,
						      Filter filter,
						      Hashtable persistent_property_docs)
			{
				this.Indexable = indexable;
				this.Filter = filter;
				this.PersistentPropDocs = persistent_property_docs;
			}