void Trust_Update(OpTrust trust)
{
// update working projects (add)
if (trust.UserID == Core.UserID)
{
OpStorage local = GetStorage(Core.UserID);
foreach (uint project in Trust.LocalTrust.Links.Keys)
{
if (!Working.ContainsKey(project))
{
if (local != null)
{
LoadHeaderFile(GetWorkingPath(project), local, false, true);
}
Working[project] = new WorkingStorage(this, project);
}
}
}
// remove all higher changes, reload with new highers (cause link changed
foreach (WorkingStorage working in Working.Values)
{
if (Core.UserID == trust.UserID || Trust.IsHigher(trust.UserID, working.ProjectID))
{
working.RemoveAllHigherChanges();
foreach (ulong uplink in Trust.GetAutoInheritIDs(Core.UserID, working.ProjectID))
{
working.RefreshHigherChanges(uplink);
}
}
}
}
public void SimCleanup()
{
FileMap.SafeClear();
InternalFileMap.SafeClear();
WorkingStorage x = Working[0];
StorageFolder packet = new StorageFolder();
packet.Name = Core.Trust.GetProjectName(0) + " Files";
x.RootFolder = new LocalFolder(null, packet);
SaveLocal(0);
}
public WorkingStorage Discard(uint project)
{
if (Core.InvokeRequired)
{
WorkingStorage previous = null;
Core.RunInCoreBlocked(delegate() { previous = Discard(project); });
return(previous);
}
if (!Working.ContainsKey(project))
{
return(null);
}
// LockAll() to prevent unlocked discarded changes from conflicting with previous versions of
// files when they are unlocked again by the user
List <LockError> errors = new List <LockError>();
Working[project].LockAll(errors);
Working.Remove(project);
// call unload on working
string path = GetWorkingPath(project);
UnloadHeaderFile(path, LocalFileKey);
// delete working file
try { File.Delete(path); }
catch { };
//loadworking
Working[project] = new WorkingStorage(this, project);
if (StorageUpdate != null)
{
Core.RunInGuiThread(StorageUpdate, GetStorage(Core.UserID));
}
return(Working[project]);
}
public StorageService(OpCore core)
{
Core = core;
Network = core.Network;
Protocol = Network.Protocol;
Store = Network.Store;
Trust = Core.Trust;
Core.SecondTimerEvent += Core_SecondTimer;
Core.MinuteTimerEvent += Core_MinuteTimer;
Network.CoreStatusChange += new StatusChange(Network_StatusChange);
Core.Transfers.FileSearch[ServiceID, FileTypeData] += new FileSearchHandler(Transfers_DataFileSearch);
Core.Transfers.FileRequest[ServiceID, FileTypeData] += new FileRequestHandler(Transfers_DataFileRequest);
Core.Trust.LinkUpdate += new LinkUpdateHandler(Trust_Update);
LocalFileKey = Core.User.Settings.FileKey;
FileCrypt.Key = LocalFileKey;
FileCrypt.IV = new byte[FileCrypt.IV.Length];
string rootpath = Core.User.RootPath + Path.DirectorySeparatorChar + "Data" + Path.DirectorySeparatorChar + ServiceID.ToString() + Path.DirectorySeparatorChar;
DataPath = rootpath + FileTypeData.ToString();
WorkingPath = rootpath + FileTypeWorking.ToString();
ResourcePath = rootpath + FileTypeResource.ToString();
Directory.CreateDirectory(DataPath);
Directory.CreateDirectory(WorkingPath);
// clear resource files so that updates of these files work
if (Directory.Exists(ResourcePath))
{
Directory.Delete(ResourcePath, true);
}
Cache = new VersionedCache(Network, ServiceID, FileTypeCache, false);
Cache.FileAquired += new FileAquiredHandler(Cache_FileAquired);
Cache.FileRemoved += new FileRemovedHandler(Cache_FileRemoved);
Cache.Load();
// load working headers
OpStorage local = GetStorage(Core.UserID);
foreach (uint project in Trust.LocalTrust.Links.Keys)
{
if (local != null)
{
LoadHeaderFile(GetWorkingPath(project), local, false, true);
}
Working[project] = new WorkingStorage(this, project);
bool doSave = false;
foreach (ulong higher in Trust.GetAutoInheritIDs(Core.UserID, project))
{
if (Working[project].RefreshHigherChanges(higher))
{
doSave = true;
}
}
Working[project].AutoIntegrate(doSave);
}
foreach (string testPath in Directory.GetFiles(DataPath))
{
if (!ReferencedPaths.Contains(testPath))
{
try { File.Delete(testPath); }
catch { }
}
}
ReferencedPaths.Clear();
Loading = false;
}
public void SaveLocal(uint project)
{
try
{
string tempPath = Core.GetTempPath();
byte[] key = Utilities.GenerateKey(Core.StrongRndGen, 256);
using (IVCryptoStream stream = IVCryptoStream.Save(tempPath, key))
{
// write loaded projects
WorkingStorage working = null;
if (Working.ContainsKey(project))
{
working = Working[project];
}
if (working != null)
{
Protocol.WriteToFile(new StorageRoot(working.ProjectID), stream);
working.WriteWorkingFile(stream, working.RootFolder, true);
working.Modified = false;
try { File.Delete(GetWorkingPath(project)); }
catch { }
}
// open old file and copy entries, except for working
OpStorage local = GetStorage(Core.UserID);
if (local != null)
{
string oldPath = GetFilePath(local);
if (File.Exists(oldPath))
{
using (TaggedStream file = new TaggedStream(oldPath, Network.Protocol))
using (IVCryptoStream crypto = IVCryptoStream.Load(file, local.File.Header.FileKey))
{
PacketStream oldStream = new PacketStream(crypto, Protocol, FileAccess.Read);
bool write = false;
G2Header g2header = null;
while (oldStream.ReadPacket(ref g2header))
{
if (g2header.Name == StoragePacket.Root)
{
StorageRoot root = StorageRoot.Decode(g2header);
write = (root.ProjectID != project);
}
//copy packet right to new file
if (write) //crit test
{
stream.Write(g2header.Data, g2header.PacketPos, g2header.PacketSize);
}
}
}
}
}
stream.WriteByte(0); // signal last packet
stream.FlushFinalBlock();
}
SavingLocal = true; // prevents auto-integrate from re-calling saveLocal
OpVersionedFile vfile = Cache.UpdateLocal(tempPath, key, BitConverter.GetBytes(Core.TimeNow.ToUniversalTime().ToBinary()));
SavingLocal = false;
Store.PublishDirect(Core.Trust.GetLocsAbove(), Core.UserID, ServiceID, FileTypeCache, vfile.SignedHeader);
}
catch (Exception ex)
{
Core.Network.UpdateLog("Storage", "Error updating local " + ex.Message);
}
if (StorageUpdate != null)
{
Core.RunInGuiThread(StorageUpdate, GetStorage(Core.UserID));
}
}
