static ArrayList RemapUris(LuceneQueryingDriver driver, ArrayList uris)
{
// We only need to remap URIs in the file system backend
if (driver.IndexName != "FileSystemIndex")
{
return(uris);
}
FileAttributesStore fa_store = new FileAttributesStore(new FileAttributesStore_Mixed(Path.Combine(PathFinder.IndexDir, "FileSystemIndex"), driver.Fingerprint));
for (int i = 0; i < uris.Count; i++)
{
Uri uri = (Uri)uris [i];
string path = uri.LocalPath;
Beagle.Daemon.FileAttributes attr = fa_store.Read(path);
if (attr == null)
{
Console.WriteLine("No file attribute info for {0}", uri);
continue;
}
Uri internal_uri = new Uri("uid:" + GuidFu.ToShortString(attr.UniqueId) + uri.Fragment);
uris [i] = internal_uri;
}
return(uris);
}
public FileAttributes ReadOrCreate (string path, Guid unique_id, out bool created)
{
lock (ifas) {
created = false;
if (Debug)
Log.Debug ("Reading or creating attr for {0}", path);
FileAttributes attr = ifas.Read (path);
if (attr == null && unique_id == Guid.Empty)
unique_id = Guid.NewGuid ();
// If we pass in a Guid that doesn't match the one we found in the
// the attributes, clobber the old attributes and the old unique Guid.
if (attr == null
|| (unique_id != Guid.Empty && unique_id != attr.UniqueId)) {
// First drop the old attribute, if there is one.
if (attr != null)
ifas.Drop (path);
// Now create the new attribute
attr = new FileAttributes ();
attr.UniqueId = unique_id;
attr.Path = path;
created = true;
}
if (Debug)
Log.Debug (" {0} attr for {1}", created ? "Created" : "Read existing", path);
return attr;
}
}
public bool Write (FileAttributes attr)
{
if (store_ea.Write (attr)) {
// Drop any now-outdated information from the sqlite store.
store_sqlite.Drop (attr.Path);
return true;
} else
return store_sqlite.Write (attr);
}
///////////////////////////////////////////////////////////
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;
}
private DirectoryModel (FileAttributes attr)
{
// Always assume an unknown state
this.state = DirectoryState.Unknown;
if (attr != null) {
this.unique_id = attr.UniqueId;
// Since we don't use the Mtime on directories,
// we can safely store the last crawl time in it.
this.last_crawl_time = attr.LastWriteTime;
}
this.cached_full_name = null;
this.cached_depth = -1;
}
// Remapping hack from DumpIndex
static Uri RemapUri(LuceneQueryingDriver driver, Uri uri)
{
// We only need to remap URIs in the file system backend
if (driver.IndexName != "FileSystemIndex")
{
return(uri);
}
FileAttributesStore fa_store = new FileAttributesStore(new FileAttributesStore_Mixed(Path.Combine(PathFinder.IndexDir, "FileSystemIndex"), driver.Fingerprint));
string path = uri.LocalPath;
Beagle.Daemon.FileAttributes attr = fa_store.Read(path);
if (attr == null)
{
Console.WriteLine("No file attribute info for {0}", uri);
return(uri);
}
return(new Uri("uid:" + GuidFu.ToShortString(attr.UniqueId) + uri.Fragment));
}
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;
}
}
public bool Write (FileAttributes fa)
{
SetPathFlag (fa.Path);
int ret = 0;
string filter_name;
// We need to quote any 's that appear in the strings
// (in particular, in the path)
lock (connection) {
// If a transaction has been requested, start it now.
MaybeStartTransaction ();
filter_name = fa.FilterName;
if (filter_name == null)
filter_name = "";
filter_name = filter_name.Replace ("'", "''");
string[] param= new string [] { "@unique_id", "@directory", "@filename", "@last_mtime", "@last_attrtime", "@filter_name", "@filter_version"};
object[] vals = new object [] {
GuidFu.ToShortString (fa.UniqueId),
fa.Directory.Replace ("'", "''"), fa.Filename.Replace ("'", "''"),
StringFu.DateTimeToString (fa.LastWriteTime),
StringFu.DateTimeToString (fa.LastAttrTime),
filter_name,
fa.FilterVersion};
for (int i=0; i < param.Length; i++)
InsertCommand.Parameters.AddWithValue (param[i], vals[i]);
ret = SqliteUtils.DoNonQuery (InsertCommand);
}
return (ret != 0);
}
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 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;
}
}
// To be used if the last_write_time to use for comparison is not the
// one obtained from path
public static bool IsUpToDate (FileAttributes attr, DateTime last_write_time)
{
if (attr == null)
return false;
return (attr.LastWriteTime >= last_write_time);
}
//////////////////////////////////////////////////////////
public static bool IsUpToDate (string path, FileAttributes attr)
{
if (attr == null)
return false;
return (attr.LastWriteTime >= FileSystem.GetLastWriteTimeUtc (path));
}
public bool Write (FileAttributes attr)
{
lock (ifas) {
if (Debug)
Log.Debug ("Writing attr for {0}", attr.Path);
attr.LastAttrTime = DateTime.UtcNow;
bool success = ifas.Write (attr);
if (Debug)
Log.Debug (" write {0}", success ? "succeeded" : "FAILED");
return success;
}
}
public DirectoryModel AddChild (string child_name, FileAttributes attr)
{
lock (big_lock) {
DirectoryModel child;
child = new DirectoryModel (attr);
child.name = child_name;
Attach_Unlocked (child);
return child;
}
}
private bool RegisterDirectory (string name, DirectoryModel parent, FileAttributes attr)
{
string path;
path = (parent == null) ? name : Path.Combine (parent.FullName, name);
if (Debug)
Logger.Log.Debug ("Registered directory '{0}' ({1})", path, attr.UniqueId);
DateTime mtime = Directory.GetLastWriteTimeUtc (path);
if (! FileSystem.ExistsByDateTime (mtime)) {
Log.Debug ("Directory '{0}' ({1}) appears to have gone away", path, attr.UniqueId);
return false;
}
DirectoryModel dir;
if (parent == null)
dir = DirectoryModel.NewRoot (big_lock, path, attr);
else
dir = parent.AddChild (name, attr);
if (mtime > attr.LastWriteTime) {
dir.State = DirectoryState.Dirty;
if (Debug)
Logger.Log.Debug ("'{0}' is dirty", path);
}
if (Debug) {
if (dir.IsRoot)
Logger.Log.Debug ("Created model '{0}'", dir.FullName);
else
Logger.Log.Debug ("Created model '{0}' with parent '{1}'", dir.FullName, dir.Parent.FullName);
}
// Add any roots we create to the list of roots
if (dir.IsRoot)
roots.Add (dir);
// Add the directory to our by-id hash, and remove any NameInfo
// we might have cached about it.
dir_models_by_id [dir.UniqueId] = dir;
name_info_by_id.Remove (dir.UniqueId);
// Start watching the directory.
dir.WatchHandle = event_backend.CreateWatch (path);
// Schedule this directory for crawling.
if (tree_crawl_task.Add (dir))
ThisScheduler.Add (tree_crawl_task);
// Make sure that our file crawling task is active,
// since presumably we now have something new to crawl.
ActivateFileCrawling ();
return true;
}
private void ScheduleDirectory (string name,
DirectoryModel parent,
FileAttributes attr,
bool is_walkable)
{
string path;
path = (parent == null) ? name : Path.Combine (parent.FullName, name);
Guid id;
id = (attr == null) ? Guid.NewGuid () : attr.UniqueId;
DateTime last_crawl;
last_crawl = (attr == null) ? DateTime.MinValue : attr.LastWriteTime;
Indexable indexable;
indexable = DirectoryToIndexable (path, id, parent);
if (indexable != null) {
indexable.LocalState ["Name"] = name;
indexable.LocalState ["LastCrawl"] = last_crawl;
indexable.LocalState ["IsWalkable"] = is_walkable;
Scheduler.Task task;
task = NewAddTask (indexable);
task.Priority = Scheduler.Priority.Delayed;
ThisScheduler.Add (task);
}
}
