protected override void DoPullProperties()
{
DateTime start_time = ParseStartingDate(FileInfo);
AddProperty(Beagle.Property.NewDate("fixme:starttime", start_time));
// FIXME: We are dropping endtime in favor of performance
// for the time being, until we can figure out how to get
// it out of the log file more efficiently.
//AddProperty (Beagle.Property.NewDate ("fixme:endtime", log.EndTime));
AddProperty(Beagle.Property.NewUnsearched("fixme:client", "Pidgin"));
string protocol = FileInfo.Directory.Parent.Parent.Name;
AddProperty(Beagle.Property.NewUnsearched("fixme:protocol", protocol));
// FIXME: Should the following properties use Property.NewKeyword and be searched?
// Gaim likes to represent many characters in hex-escaped %xx form
string speaking_to = StringFu.HexUnescape(FileInfo.Directory.Name);
AddProperty(Beagle.Property.NewKeyword("fixme:speakingto", speaking_to));
string identity = StringFu.HexUnescape(FileInfo.Directory.Parent.Name);
AddProperty(Beagle.Property.NewUnsearched("fixme:identity", identity));
}
public IMLog(Beagle.Hit hit, Beagle.Query query) : base(hit, query)
{
Group = TileGroup.Conversations;
Subject.LabelProp = Catalog.GetString("IM Conversation");
string alias = hit.GetFirstProperty("fixme:speakingto_alias");
string name = hit.GetFirstProperty("fixme:speakingto");
if (alias != null && alias != "")
{
From.LabelProp = "<b>" + alias + "</b>";
}
else if (name != null && name != "")
{
From.LabelProp = "<b>" + name + "</b>";
}
else
{
From.LabelProp = "(unknown)";
}
try {
string starttime = hit.GetFirstProperty("fixme:starttime");
if (!String.IsNullOrEmpty(starttime))
{
Timestamp = StringFu.StringToDateTime(starttime);
}
Date.LabelProp = Utils.NiceShortDate(Timestamp);
} catch {}
}
public MailMessage(Beagle.Hit hit, Beagle.Query query) : base(hit, query)
{
Group = TileGroup.Conversations;
string title = Utils.GetFirstPropertyOfParent(hit, "dc:title");
if (title == null || title == String.Empty)
{
title = Catalog.GetString("(untitled)");
}
Subject.LabelProp = Title = title;
From.LabelProp = "<b>" + GetAddress(hit) + "</b>";
try {
Timestamp = StringFu.StringToDateTime(Utils.GetFirstPropertyOfParent(hit, "fixme:date"));
Date.LabelProp = Utils.NiceShortDate(Timestamp);
} catch {}
if (Utils.GetFirstPropertyOfParent(Hit, "fixme:client") == "evolution")
{
AddAction(new TileAction(Catalog.GetString("Send in Mail"), SendInMail));
}
if ((Utils.GetFirstPropertyOfParent(hit, "fixme:isSent") == null))
{
AddAction(new TileAction(Catalog.GetString("Find Messages From Sender"), Gtk.Stock.Find, FindAllFromSender));
}
}
// FIXME: I don't really like this, the collection could be huge
public ArrayList GetOlderThan(DateTime dt)
{
SqliteCommand command;
SqliteDataReader reader;
lock (connection) {
command = new SqliteCommand();
command.Connection = connection;
command.CommandText =
"SELECT uid FROM mapping WHERE last_seen < " +
StringFu.DateTimeToString(dt);
reader = SqliteUtils.ExecuteReaderOrWait(command);
ArrayList uids = new ArrayList();
while (SqliteUtils.ReadOrWait(reader))
{
uids.Add(reader.GetString(0));
}
reader.Close();
command.Dispose();
return(uids);
}
}
private static List <SnippetLine> GetSnippet(SnippetRequest request)
{
Queryable queryable = QueryDriver.GetQueryable(request.Hit.Source);
ISnippetReader snippet_reader;
bool full_text = request.FullText;
int ctx_length = request.ContextLength;
int snp_length = request.SnippetLength;
if (queryable == null)
{
Console.WriteLine("SnippetExecutor: No queryable object matches '{0}'", request.Hit.Source);
snippet_reader = new SnippetReader(null, null, false, -1, -1);
full_text = false;
}
else
{
snippet_reader = queryable.GetSnippet(request.QueryTerms, request.Hit, full_text, ctx_length, snp_length);
}
List <SnippetLine> snippetlines = new List <SnippetLine> ();
if (snippet_reader == null)
{
return(snippetlines);
}
if (!full_text)
{
foreach (SnippetLine snippet_line in snippet_reader.GetSnippet())
{
snippetlines.Add(snippet_line);
}
}
else
{
SnippetLine snippet_line = new SnippetLine();
snippet_line.Line = 1;
Fragment fragment = new Fragment();
fragment.QueryTermIndex = -1;
StringBuilder sb = new StringBuilder();
string line;
// Read data from snippet_reader and write
while ((line = snippet_reader.ReadLine()) != null)
{
sb.Append(StringFu.CleanupInvalidXmlCharacters(line));
sb.Append("\n");
}
fragment.Text = sb.ToString();
snippet_line.Fragments = new ArrayList();
snippet_line.Fragments.Add(fragment);
snippetlines.Add(snippet_line);
}
snippet_reader.Close();
return(snippetlines);
}
private string GetPreview(ImLog log)
{
string preview = null;
if (log.Utterances.Count == 0)
{
return(String.Empty);
}
foreach (ImLog.Utterance utt in log.Utterances)
{
string snippet = utt.Text;
int word_count = StringFu.CountWords(snippet, 15);
if (word_count > 3)
{
preview = snippet;
break;
}
}
if (preview == null)
{
preview = ((ImLog.Utterance)log.Utterances [0]).Text;
}
if (preview.Length > 50)
{
preview = preview.Substring(0, 50) + "...";
}
return(preview);
}
// Returns the full directory path for this value, after stripping end '/' and expanding env variable
private static string GetExcludeDirectory(string value)
{
if (String.IsNullOrEmpty(value))
{
return(null);
}
// Remove end '/'
if (value != "/")
{
value = value.TrimEnd('/');
}
value = StringFu.ExpandEnvVariables(value);
if (String.IsNullOrEmpty(value))
{
return(null);
}
value = Path.GetFullPath(value);
if (Directory.Exists(value))
{
return(value);
}
return(null);
}
private static string ReadKDEConfig(string kde_dir)
{
string kmailrc = kde_dir;
kmailrc = Path.Combine(kmailrc, "share");
kmailrc = Path.Combine(kmailrc, "config");
kmailrc = Path.Combine(kmailrc, "kmailrc");
if (!File.Exists(kmailrc))
{
return(null);
}
using (StreamReader reader = new StreamReader(kmailrc)) {
string section = "";
string line;
while ((line = reader.ReadLine()) != null)
{
if (line.StartsWith("[") && line.EndsWith("]"))
{
section = line;
}
if (section == "[General]")
{
if (line.StartsWith("folders=") && line.Length > 8)
{
return(StringFu.ExpandEnvVariables(line.Substring(8)));
}
}
}
}
return(null);
}
/////////////////////////////////////////////////////////////
// Load data from configuration. Intersect deltas to the currently active excludes and
// implement any changes upon notification.
private void LoadConfiguration()
{
Config config = Conf.Get(Conf.Names.FilesQueryableConfig);
List <string[]> values = config.GetListOptionValues(Conf.Names.ExcludeSubdirectory);
if (values != null)
{
foreach (string[] value in values)
{
AddExcludeDir(GetExcludeDirectory(value [0]));
}
}
values = config.GetListOptionValues(Conf.Names.ExcludePattern);
if (values != null)
{
foreach (string[] exclude in values)
{
// RemoveQuotes from beginning and end
AddExcludePattern(exclude [0]);
}
}
exclude_regex = StringFu.GetPatternRegex(exclude_patterns);
Conf.WatchForUpdates();
Conf.Subscribe(Conf.Names.FilesQueryableConfig, OnConfigurationChanged);
}
static protected double HalfLifeMultiplierFromProperty(Hit hit,
double default_multiplier,
params object [] properties)
{
double best_m = -1.0;
foreach (object obj in properties)
{
string key = obj as string;
string val = hit [key];
if (val != null)
{
DateTime dt = StringFu.StringToDateTime(val);
double this_m;
this_m = HalfLifeMultiplier(dt, 182); /* 182 days == six months */
if (this_m > best_m)
{
best_m = this_m;
}
}
}
if (best_m < 0)
{
best_m = default_multiplier;
}
return(best_m);
}
public void GotSnippet(string text)
{
snippet.Markup = text;
string tip = text.Replace("<b>", String.Empty).Replace("</b>", String.Empty);
snippet_tip.SetTip(snippet, StringFu.ConvertSpecialEntities(tip), null);
}
private static ResponseMessage AddRemovableIndex(string path, string mnt_dir)
{
DirectoryInfo index_dir = new DirectoryInfo(StringFu.SanitizePath(path));
if (!index_dir.Exists)
{
ErrorResponse msg;
msg = new ErrorResponse();
msg.ErrorMessage = "Adding removable index failed";
msg.Details = String.Format("'{0}' does not exist.", path);
return(msg);
}
// Allow late loading of mount dir ?
mnt_dir = StringFu.SanitizePath(mnt_dir);
if (!Directory.Exists(mnt_dir))
{
ErrorResponse msg;
msg = new ErrorResponse();
msg.ErrorMessage = "Adding removable index failed";
msg.Details = String.Format("Mount directory '{0}' does not exist.", mnt_dir);
return(msg);
}
if (removable_queryables.ContainsKey(path))
{
ErrorResponse msg;
msg = new ErrorResponse();
msg.ErrorMessage = "Adding removable index failed";
msg.Details = String.Format("'{0}' already added.", path);
return(msg);
}
Queryable removable_queryable = null;
try {
iqueryable_lock.AcquireWriterLock(System.Threading.Timeout.Infinite);
removable_queryable = StaticQueryable.LoadRemovableQueryable(index_dir, mnt_dir);
} finally {
iqueryable_lock.ReleaseWriterLock();
}
if (removable_queryable == null)
{
return(new ErrorResponse("Adding removable index failed"));
}
iqueryable_to_queryable [removable_queryable.IQueryable] = removable_queryable;
removable_queryables [path] = removable_queryable;
RemovableIndexResponse resp = new RemovableIndexResponse();
resp.Source = removable_queryable.Name;
Log.Info("Adding removable index '{0}' from {1}", resp.Source, path);
return(resp);
}
protected override void PopulateTemplate()
{
base.PopulateTemplate();
Template["nice_duration"] = "(" +
StringFu.DurationToPrettyString(
StringFu.StringToDateTime(Hit ["fixme:endtime"]),
StringFu.StringToDateTime(Hit ["fixme:starttime"])) + ")";
if (Template ["nice_duration"] == "()")
{
Template ["nice_duration"] = "";
}
if (email != null)
{
Template ["SendMailAction"] = Catalog.GetString("Send Mail");
}
// FIXME: This is a temporary hack until gaim supports other protocols than AIM via gaim-remote
if (Hit ["fixme:protocol"] == "aim")
{
Template ["SendIMAction"] = Catalog.GetString("Send IM");
}
speaking_alias = (Hit ["fixme:speakingto_alias"] != null) ? Hit ["fixme:speakingto_alias"] : Hit ["fixme:speakingto"];
// FIXME: Hack to figure out if the conversation is taken place in a chat room
if (Hit["fixme:speakingto"].EndsWith(".chat"))
{
Template["title"] = String.Format(Catalog.GetString("Conversation in {0}"), speaking_alias.Replace(".chat", ""));
}
else
{
Template["title"] = String.Format(Catalog.GetString("Conversation with {0}"), speaking_alias);
}
if (Hit ["fixme:speakingto_icon"] != null && File.Exists(Hit ["fixme:speakingto_icon"]))
{
Template["Icon"] = StringFu.PathToQuotedFileUri(Hit ["fixme:speakingto_icon"]);
}
else
{
Template["Icon"] = Images.GetHtmlSource("gnome-gaim.png", "image/png");
}
#if ENABLE_GALAGO
if (Hit ["fixme:protocol"] == "aim")
{
string status = GalagoTools.GetPresence(Hit ["fixme:protocol"], Hit["fixme:speakingto"]);
if (status != null && status != "")
{
Template ["Presence"] = status;
}
}
#endif
}
protected override void PopulateTemplate()
{
base.PopulateTemplate();
string photo_filename = Hit["beagle:Photo"];
if (photo_filename != null)
{
System.Console.WriteLine("photo: {0}", photo_filename);
string height = "";
try {
// bad hack to scale the image
Gdk.Pixbuf pixbuf = new Gdk.Pixbuf(photo_filename);
if (pixbuf.Width > pixbuf.Height)
{
if (pixbuf.Width > 80)
{
height = "width=\"80\"";
}
}
else
{
if (pixbuf.Height > 80)
{
height = "height=\"80\"";
}
}
} catch {
}
Template["size_adjustment"] = height;
Template["Icon"] = StringFu.PathToQuotedFileUri(photo_filename);
}
else
{
Template["size_adjustment"] = "";
Template["Icon"] = default_contact_icon_data;
}
if (Hit["fixme:ImAim"] != null)
{
Template["CanSendIm"] = "";
}
#if ENABLE_GALAGO
if (Hit ["fixme:ImAim"] != null)
{
string status = GalagoTools.GetPresence("aim", Hit ["fixme:ImAim"]);
if (status != null && status != "")
{
Template ["Presence"] = status;
}
}
#endif
}
public PidginLog(FileInfo file, TextReader reader) : base("Pidgin", file, reader)
{
string filename = file.Name;
// Parse what we can from the file path
try {
string str;
// Character at position 17 will be either a dot, indicating the beginning
// of the extension for old gaim logs, or a plus or minus indicating a
// timezone offset for new gaim logs.
if (filename [17] == '+' || filename [17] == '-')
{
// New gaim 2.0.0 format, including timezone.
//
// Ugly hack time: DateTime's format specifiers only know how to
// deal with timezones in the format "+HH:mm" and not "+HHmm",
// which is how UNIX traditionally encodes them. I have no idea
// why; it would make RFC 822/1123 parsing a hell of a lot easier.
// Anyway, in this case, we're going to insert a colon in there so
// that DateTime.ParseExact can understand it.
//
// 2006-02-21-160424-0500EST.html
// ^
// offset 20
str = filename.Substring(0, 20) + ':' + filename.Substring(20, 2);
StartTime = DateTime.ParseExact(str, "yyyy-MM-dd.HHmmsszzz", null);
}
else if (filename [17] == '.')
{
// Older gaim format.
//
// 2006-02-21-160424.html
str = Path.GetFileNameWithoutExtension(filename);
StartTime = DateTime.ParseExact(str, "yyyy-MM-dd.HHmmss", null);
}
else
{
throw new FormatException();
}
} catch {
Logger.Log.Warn("Could not parse date/time from filename '{0}'", file.Name);
StartTime = DateTime.Now;
}
// Gaim likes to represent many characters in hex-escaped %xx form
SpeakingTo = StringFu.HexUnescape(file.Directory.Name);
Identity = StringFu.HexUnescape(file.Directory.Parent.Name);
Protocol = file.Directory.Parent.Parent.Name;
Load();
}
public void Update(string uid, uint flags)
{
lock (connection) {
SqliteUtils.DoNonQuery(connection,
"INSERT OR REPLACE INTO mapping " +
" (uid, flags, last_seen) " +
" VALUES (@uid, @flags, @last_seen)",
new string [] { "@uid", "@flags", "@last_seen" },
new object [] { uid, flags, StringFu.DateTimeToString(DateTime.UtcNow) });
}
}
static public Property NewDate(string key, DateTime dt)
{
Property p = new Property();
p.type = PropertyType.Date;
p.Key = key;
p.Value = StringFu.DateTimeToString(dt);
p.is_searched = true;
p.is_stored = true;
return(p);
}
public static string NiceShortTime(string timestamp)
{
DateTime dt;
try {
dt = StringFu.StringToDateTime(timestamp);
} catch {
return("");
}
return(NiceShortTime(dt));
}
protected override void PopulateTemplate()
{
base.PopulateTemplate();
if (Hit.FileInfo == null)
{
Console.WriteLine("FileInfo is null");
return;
}
string quoted_uri = StringFu.PathToQuotedFileUri(Hit.Uri.LocalPath);
string thumbnail = Thumbnail.PathForUri(quoted_uri, ThumbnailSize.Normal);
if (File.Exists(thumbnail))
{
Template ["Icon"] = Images.GetHtmlSource(thumbnail, Hit.MimeType);
}
else
{
Pixbuf pix = thumb_factory.GenerateThumbnail(quoted_uri, Hit.MimeType);
FileInfo fi = new FileInfo(Hit.Uri.LocalPath);
if (pix == null)
{
thumb_factory.CreateFailedThumbnail(quoted_uri, fi.LastWriteTime);
string path = GnomeFu.GetMimeIconPath(Hit.MimeType);
string icon = Images.GetHtmlSource(path, Hit.MimeType);
if (icon != null)
{
Template ["Icon"] = icon;
}
else
{
Template ["Icon"] = Images.GetHtmlSource("document", "image/png");
}
}
else
{
thumb_factory.SaveThumbnail(pix, quoted_uri, DateTime.Now);
Template ["Icon"] = Images.GetHtmlSource(thumbnail, Hit.MimeType);
}
}
Template["Title"] = Hit ["dc:title"];
if (Template["Title"] == null)
{
Template["Title"] = Template["FileName"];
}
}
///////////////////////////////////////////////////////////
static public DirectoryModel NewRoot(object big_lock, string path, FileAttributes attr)
{
path = StringFu.SanitizePath(path);
DirectoryModel root;
root = new DirectoryModel(attr);
root.big_lock = big_lock;
root.rooted_to = FileSystem.GetDirectoryNameRootOk(path);
root.name = Path.GetFileName(path);
return(root);
}
static Uri PathToUri(string fullpath)
{
if (!arg_removable)
{
return(UriFu.PathToFileUri(fullpath));
}
fullpath = PathInIndex(fullpath);
return(new Uri(String.Format("removable{0}{1}{2}",
Uri.SchemeDelimiter,
volume_label,
StringFu.HexEscape(fullpath)), true));
}
public void AddMatchFragment(int query_term_index, string text)
{
text = StringFu.CleanupInvalidXmlCharacters(text);
if (String.IsNullOrEmpty(text))
{
return;
}
if (Fragments == null)
{
Fragments = new ArrayList(3); // mostly will be 3 fragments
}
// Before we send a snippet over the wire, clean up any
// characters that would be invalid in XML.
Fragments.Add(new Fragment(query_term_index, text));
}
static public ICollection GetMatchingHammers(string pattern)
{
ArrayList matches;
matches = new ArrayList();
foreach (Pair pair in all_pairs)
{
if (StringFu.GlobMatch(pattern, pair.Attribute.Name))
{
matches.Add(pair.CreateInstance());
}
}
return(matches);
}
/// <summary>
/// Standard properties for files
/// Used by FileSystem backend and filters which produce file child-indexables
/// </summary>
/// <param name="name">
/// A <see cref="System.String"/>
/// </param>
/// <param name="mutable">
/// A <see cref="System.Boolean"/>
/// </param>
/// <returns>
/// A <see cref="IEnumerable"/>
/// </returns>
public static IEnumerable StandardFileProperties(string name, bool mutable)
{
StringBuilder sb;
sb = new StringBuilder();
string no_ext, ext, no_punct;
no_ext = Path.GetFileNameWithoutExtension(name);
ext = Path.GetExtension(name).ToLower();
sb.Append(no_ext);
for (int i = 0; i < sb.Length; ++i)
{
if (!Char.IsLetterOrDigit(sb [i]))
{
sb [i] = ' ';
}
}
no_punct = sb.ToString();
Property prop;
prop = Property.NewKeyword(ExactFilenamePropKey, name);
prop.IsMutable = mutable;
yield return(prop);
prop = Property.New(TextFilenamePropKey, no_ext);
prop.IsMutable = mutable;
yield return(prop);
prop = Property.New(NoPunctFilenamePropKey, no_punct);
prop.IsMutable = mutable;
yield return(prop);
prop = Property.NewUnsearched(FilenameExtensionPropKey, ext);
prop.IsMutable = mutable;
yield return(prop);
string str;
str = StringFu.FuzzyDivide(no_ext);
prop = Property.New(SplitFilenamePropKey, str);
prop.IsMutable = mutable;
yield return(prop);
}
public void WriteXml(XmlWriter writer)
{
writer.WriteAttributeString("FullText", (FullText ? "true" : "false"));
if (snippet_reader == null)
{
return;
}
if (FullText)
{
writer.WriteStartElement("SnippetLine");
writer.WriteAttributeString("Line", "1");
writer.WriteStartElement("Fragment");
writer.WriteAttributeString("QueryTermIndex", "-1");
string line;
// Read data from snippet_reader and write
while ((line = snippet_reader.ReadLine()) != null)
{
writer.WriteString(StringFu.CleanupInvalidXmlCharacters(line));
writer.WriteString("\n");
}
writer.WriteEndElement();
writer.WriteEndElement();
}
else if (snippet_reader.GetSnippet() != null)
{
// If fulltext is false, read lines from snippet reader
foreach (SnippetLine snippet_line in snippet_reader.GetSnippet())
{
writer.WriteStartElement("SnippetLine");
writer.WriteAttributeString("Line", Convert.ToString(snippet_line.Line));
foreach (Fragment fragment in snippet_line.Fragments)
{
writer.WriteStartElement("Fragment");
writer.WriteAttributeString("QueryTermIndex", Convert.ToString(fragment.QueryTermIndex));
writer.WriteString(fragment.Text);
writer.WriteEndElement();
}
writer.WriteEndElement();
}
}
snippet_reader.Close();
}
private FileAttributes GetFromReader(SqliteDataReader reader)
{
FileAttributes attr = new FileAttributes();
attr.UniqueId = GuidFu.FromShortString(reader.GetString(0));
attr.Path = System.IO.Path.Combine(reader.GetString(1), reader.GetString(2));
attr.LastWriteTime = StringFu.StringToDateTime(reader.GetString(3));
attr.LastAttrTime = StringFu.StringToDateTime(reader.GetString(4));
attr.FilterName = reader.GetString(5);
attr.FilterVersion = int.Parse(reader.GetString(6));
if (attr.FilterName == "")
{
attr.FilterName = null;
}
return(attr);
}
public bool IsMatch(Uri uri, string extension, string mime_type)
{
if (Uri != null && (uri == null || !StringFu.GlobMatch(Uri, uri.ToString())))
{
return(false);
}
if (Extension != null && (extension == null || !StringFu.GlobMatch(Extension, extension)))
{
return(false);
}
if (MimeType != null && (mime_type == null || !StringFu.GlobMatch(MimeType, mime_type)))
{
return(false);
}
return(true);
}
public bool Write(FileAttributes attr)
{
if (Disable)
{
return(false);
}
try {
if (ExtendedAttribute.OldExists(attr.Path, "Fingerprint"))
{
DropObsoleteAttributes(attr.Path);
}
string fingerprint = String.Format("{0:00} {1}", EA_VERSION, index_fingerprint);
string uid = GuidFu.ToShortString(attr.UniqueId);
string mtime = StringFu.DateTimeToString(attr.LastWriteTime);
string filter = String.Empty;
if (attr.HasFilterInfo)
{
filter = String.Format("{0:000} {1}", attr.FilterVersion, attr.FilterName);
}
attr.LastAttrTime = DateTime.UtcNow;
string attrtime = StringFu.DateTimeToString(attr.LastAttrTime);
string [] csv = { fingerprint, uid, mtime, attrtime, filter };
ExtendedAttribute.Set(attr.Path, String.Join(",", csv));
return(true);
} catch (IOException e) {
// An IOException here probably means that we don't have the right
// permissions to set the EAs. We just fail silently and return false rather
// than spewing a bunch of scary exceptions.
//Logger.Log.Debug (e);
return(false);
} catch (Exception e) {
//Logger.Log.Debug (e, "Caught exception writing EAs to {0}", attr.Path);
// FIXME: Do something smarter with the exception.
return(false);
}
}
public FileAttributes Read(string path)
{
if (Disable)
{
return(null);
}
try {
string tmp = ExtendedAttribute.Get(path);
if (tmp == null)
{
return(null);
}
string[] csv = tmp.Split(',');
if (int.Parse(csv [0].Substring(0, 2)) != EA_VERSION ||
(index_fingerprint != null && csv [0].Substring(3) != index_fingerprint))
{
return(null);
}
FileAttributes attr = new FileAttributes();
attr.UniqueId = GuidFu.FromShortString(csv [1]);
attr.Path = path;
attr.LastWriteTime = StringFu.StringToDateTime(csv [2]);
attr.LastAttrTime = StringFu.StringToDateTime(csv [3]);
if (!String.IsNullOrEmpty(csv [4]))
{
attr.FilterVersion = int.Parse(csv [4].Substring(0, 3));
attr.FilterName = csv [4].Substring(4);
}
return(attr);
} catch (Exception e) {
//Logger.Log.Debug ("Caught exception reading EAs from {0}", path);
//Logger.Log.Debug (e);
// FIXME: Do something smarter with the exception.
return(null);
}
}
// Scans configuration for user-specified index paths
// to load StaticQueryables from.
static void LoadStaticQueryables()
{
int count = 0;
if (UseQueryable("static"))
{
Logger.Log.Info("Loading user-configured static indexes.");
List <string[]> values = Conf.Daemon.GetListOptionValues(Conf.Names.StaticQueryables);
if (values != null)
{
foreach (string[] path in values)
{
static_queryables.Add(path [0]);
}
}
}
Queryable queryable;
foreach (string path in static_queryables)
{
DirectoryInfo index_dir = new DirectoryInfo(StringFu.SanitizePath(path));
if (!index_dir.Exists)
{
continue;
}
// FIXME: QueryDomain might be other than local
queryable = StaticQueryable.LoadStaticQueryable(index_dir, QueryDomain.Local);
if (queryable != null)
{
iqueryable_to_queryable [queryable.IQueryable] = queryable;
count++;
}
}
Logger.Log.Info("Found {0} user-configured static indexes..", count);
static_queryables = null;
}
