Exemple #1
0
        public void AddHigherChange(ulong id, StorageFile change)
        {
            if (!HigherChanges.ContainsKey(id))
                HigherChanges[id] = new List<StorageItem>();

            HigherChanges[id].Add(change);
        }
Exemple #2
0
        public FileItem(StorageView view, FolderNode parent, StorageFile file, bool temp)
        {
            View = view;
            Folder = parent;

            SubItems.Add("");
            SubItems.Add("");

            Details = file;
            Temp = temp;

            UpdateInterface();
        }
Exemple #3
0
        private LocalFile CreateNewFile(string name)
        {
            StorageFile info = new StorageFile();
            LocalFile file = new LocalFile(info);

            info.UID = Utilities.StrongRandUInt64(Core.StrongRndGen);
            info.Name = name;
            info.Date = Core.TimeNow.ToUniversalTime();
            info.Revs = 5;

            file.Archived.SafeAddFirst(info);

            return file;
        }
Exemple #4
0
        public DiffForm(InfoPanel info, ulong whoID, string what, StorageFile file, bool history)
        {
            InitializeComponent();

            Core = info.ParentView.Core;
            Info = info;
            Target = file;
            TargetID = whoID;
            TargetHistory = history;

            Text = Target.Name + " Differences";

            // set what txt
                // my/ben's Changes
                // my/ben's Integrated Changes
                // my/ben's History from <date>

            string who = (whoID == Core.UserID) ? "My" : (Core.GetName(whoID) + "'s");

            WhatLabel.Text = who + " " + what;

            // local
            if (!info.CurrentFile.Temp)
            {
                if (Utilities.MemCompare(Target.InternalHash, ((StorageFile)Info.CurrentFile.Details).InternalHash))
                    LocalNote.Text = "Identical";
            }
            else
                CurrentRadio.Enabled = false;

            // changes
            foreach (ChangeRow change in Info.SortChanges(Info.CurrentChanges))
                ChangesCombo.Items.Add(new ComboFileItem(this, change.ID, (StorageFile) change.Item));

            if (ChangesCombo.Items.Count > 0)
                ChangesCombo.SelectedIndex = 0;
            else
                ChangesRadio.Enabled = false;

            // integrated
            foreach (ChangeRow integrated in Info.SortChanges(Info.CurrentIntegrated))
                IntegratedCombo.Items.Add(new ComboFileItem(this, integrated.ID, (StorageFile)integrated.Item));

            if (IntegratedCombo.Items.Count > 0)
                IntegratedCombo.SelectedIndex = 0;
            else
                IntegratedRadio.Enabled = false;

            // history
            info.CurrentFile.Archived.LockReading(delegate()
            {
                foreach (StorageFile item in info.CurrentFile.Archived)
                    HistoryCombo.Items.Add(new ComboFileItem(this, 0, item));
            });

            if (HistoryCombo.Items.Count > 0)
                HistoryCombo.SelectedIndex = 0;
            else
                HistoryRadio.Enabled = false;

            // using
            UsingCombo.Items.Add("WinMerge");
            UsingCombo.Items.Add("Open Seperately");
            UsingCombo.Items.Add("Another Tool...");
            UsingCombo.SelectedIndex = 0;
        }
Exemple #5
0
        public StorageFile Clone()
        {
            // clones everything except notes

            StorageFile clone = new StorageFile();

            clone.UID = UID;
            clone.Name = Name;
            clone.Date = Date;
            clone.Flags = Flags;
            clone.Revs = Revs;

            clone.Size = Size;
            clone.Hash = Hash;
            clone.HashID = HashID;
            clone.FileKey = FileKey;

            clone.InternalSize = InternalSize;
            clone.InternalHash = InternalHash;
            clone.InternalHashID = InternalHashID;

            return clone;
        }
Exemple #6
0
        public FileItem AddFileInfo(StorageFile info, bool remote)
        {
            if (!Files.ContainsKey(info.UID))
                Files[info.UID] = new FileItem(View, this, info, remote);

            FileItem file = Files[info.UID];

            if (!remote)
            {
                if (info.IntegratedID != 0)
                    file.Integrated.SafeAdd(info.IntegratedID, info);
                else
                    file.Archived.SafeAddLast(info);
            }

            return file;
        }
Exemple #7
0
        public void ReadyChange(LocalFile file, StorageFile newInfo)
        {
            Modified = true;
            PeriodicSave = true;

            file.Modify(Core.TimeNow, newInfo);
        }
Exemple #8
0
 // used for unexpected (file) and existing errors
 public LockError(string path, string message, bool isFile, LockErrorType type, StorageFile file, bool history)
 {
     Path = path;
     Message = message;
     IsFile = isFile;
     Type = type;
     File = file;
     History = history;
 }
Exemple #9
0
        public string UnlockFile(ulong dht, uint project, string path, StorageFile file, bool history, List<LockError> errors)
        {
            // path needs to include name, because for things like history files name is diff than file.Info

            string finalpath = GetRootPath(dht, project) + path;

            finalpath += history ? Path.DirectorySeparatorChar + ".history" + Path.DirectorySeparatorChar : Path.DirectorySeparatorChar.ToString();

            if (!CreateFolder(finalpath, errors, false))
                return null;

            finalpath += history ? GetHistoryName(file) : file.Name;

            // file not in storage
            if(!FileMap.SafeContainsKey(file.HashID) || !File.Exists(GetFilePath(file.HashID)))
            {
                errors.Add(new LockError(finalpath, "", true, LockErrorType.Missing));
                return null;
            }

            // check if already unlocked
            if (File.Exists(finalpath) && file.IsFlagged(StorageFlags.Unlocked))
                return finalpath;

            // file already exists
            if(File.Exists(finalpath))
            {

                // ask user about local
                if (dht == Core.UserID)
                {
                    errors.Add(new LockError(finalpath, "", true, LockErrorType.Existing, file, history));

                    return null;
                }

                // overwrite remote
                else
                {
                    try
                    {
                        File.Delete(finalpath);
                    }
                    catch
                    {
                        // not an existing error, dont want to give user option to 'use' the old remote file
                        errors.Add(new LockError(finalpath, "", true, LockErrorType.Unexpected, file, history));
                        return null;
                    }
                }
            }

            // extract file
            try
            {
                Utilities.DecryptTagFile(GetFilePath(file.HashID), finalpath, file.FileKey, Core);
            }
            catch (Exception ex)
            {
                Core.Network.UpdateLog("Storage", "UnlockFile: " + ex.Message);

                errors.Add(new LockError(finalpath, "", true, LockErrorType.Unexpected, file, history));
                return null;
            }

            file.SetFlag(StorageFlags.Unlocked);

            if (dht != Core.UserID)
            {
                //FileInfo info = new FileInfo(finalpath);
                //info.IsReadOnly = true;
            }

            // local
            else if (Working.ContainsKey(project) )
            {
                // let caller trigger event because certain ops unlock multiple files

                // set watch on root path
                Working[project].StartWatchers();
            }

            return finalpath;
        }
Exemple #10
0
        public void LockFile(ulong dht, uint project, string path, StorageFile file, bool history)
        {
            string finalpath = GetRootPath(dht, project) + path;

            if (history)
                finalpath += Path.DirectorySeparatorChar + ".history" + Path.DirectorySeparatorChar + GetHistoryName(file);
            else
                finalpath += Path.DirectorySeparatorChar + file.Name;

            try
            {
                if (File.Exists(finalpath))
                    File.Delete(finalpath);

                file.RemoveFlag(StorageFlags.Unlocked);
            }
            catch { }
        }
Exemple #11
0
        public bool IsFileUnlocked(ulong dht, uint project, string path, StorageFile file, bool history)
        {
            string finalpath = GetRootPath(dht, project) + path;

            if (history)
                finalpath += Path.DirectorySeparatorChar + ".history" + Path.DirectorySeparatorChar + GetHistoryName(file);
            else
                finalpath += Path.DirectorySeparatorChar + file.Name;

            return File.Exists(finalpath);
        }
Exemple #12
0
        public bool FileExists(StorageFile file)
        {
            if (FileMap.SafeContainsKey(file.HashID) &&
                File.Exists(GetFilePath(file.HashID)))
                return true;

            return false;
        }
Exemple #13
0
        public string DownloadStatus(StorageFile file)
        {
            // returns null if file not being handled by transfer component

            if (file.Hash == null) // happens if file is being added to storage
                return null;

            return Core.Transfers.GetDownloadStatus(ServiceID, file.Hash, file.Size);
        }
Exemple #14
0
        public void DownloadFile(ulong id, StorageFile file)
        {
            // called from hash thread
            if (Core.InvokeRequired)
            {
                Core.RunInCoreAsync(delegate() { DownloadFile(id, file); });
                return;
            }

            // if file still processing return
            if (file.Hash == null)
                return;

            FileDetails details = new FileDetails(ServiceID, FileTypeData, file.Hash, file.Size, null);

            Core.Transfers.StartDownload(id, details, GetFilePath(file.HashID), new EndDownloadHandler(EndDownloadFile), new object[] { file });
        }
Exemple #15
0
        private void ReviseFile(HashPack pack, StorageFile info)
        {
            // called from hash thread
            if (Core.InvokeRequired)
            {
                Core.RunInCoreAsync(() => ReviseFile(pack, info));
                return;
            }

            if (Working.ContainsKey(pack.Project))
                Working[pack.Project].ReadyChange(pack.File, info);

            CallFileUpdate(pack.Project, pack.Dir, info.UID, WorkingChange.Updated);
        }
Exemple #16
0
        public LocalFile AddFileInfo(StorageFile info)
        {
            LocalFile file = null;

            if (!Files.SafeTryGetValue(info.UID, out file))
            {
                file = new LocalFile(info);
                Files.SafeAdd(info.UID, file);
            }

            if(info.IntegratedID != 0)
                file.Integrated.SafeAdd(info.IntegratedID, info);
            else
                file.Archived.SafeAddLast(info);

            return file;
        }
Exemple #17
0
        void ReplaceFile(LocalFile file, StorageFile replacement, string dir, bool setModified, List<LockError> errors)
        {
            // this will lock file if it is unlocked
            bool unlocked = Storages.IsFileUnlocked(Core.UserID, ProjectID, dir, file.Info, false);

            Storages.LockFile(Core.UserID, ProjectID, dir, file.Info, false);

            if (setModified)
                ReadyChange(file, replacement);
            else
            {
                file.Info = replacement;
                file.Archived.SafeAddFirst(replacement);
            }

            if (unlocked)
                Storages.UnlockFile(Core.UserID, ProjectID, dir, file.Info, false, errors);
        }
Exemple #18
0
 public OpFile(StorageFile file)
 {
     HashID = file.HashID;
     Hash = file.Hash;
     Size = file.Size;
     Key = file.FileKey;
     Working = true;
 }
Exemple #19
0
 public LocalFile(StorageFile info)
 {
     Info = info;
 }
Exemple #20
0
        private string GetHistoryName(StorageFile file)
        {
            string name = file.Name;

            int pos = name.LastIndexOf('.');
            if (pos == -1)
                pos = name.Length;

            string tag = "unhashed";
            if(file.InternalHash != null)
                tag = Utilities.BytestoHex(file.InternalHash, 0, 3, false);

            name = name.Insert(pos, "-" + tag);

            return name;
        }
Exemple #21
0
        public void IntegrateFile(string path, ulong who, StorageFile change)
        {
            // put file in local's integration map for this user id

            LocalFolder folder = GetLocalFolder(path);
            LocalFile file = null;

            if(!folder.Files.SafeTryGetValue(change.UID, out file))
                return;

            file.Integrated.SafeAdd(who, change.Clone());
            // dont set file.info modified, because hash hasn't changed

            Modified = true;
            PeriodicSave = true;

            Storages.CallFileUpdate(ProjectID, path, file.Info.UID, WorkingChange.Updated);
        }
Exemple #22
0
        public void ReplaceFile(string path, StorageFile replacement, List<LockError> errors)
        {
            string name = Path.GetFileName(path);
            string dir = Utilities.StripOneLevel(path);

            LocalFolder folder = GetLocalFolder(dir);
            LocalFile file = folder.GetFile(name);

            ReplaceFile(file, replacement, dir, true, errors);

            Storages.CallFileUpdate(ProjectID, folder.GetPath(), file.Info.UID, WorkingChange.Updated);
        }
Exemple #23
0
        private void SelectFolder(FolderNode folder)
        {
            if (folder == null)
                return;

            /*
             *
             * if (!SelectedInfo.IsFile && SelectedInfo.CurrentFolder != null)
            {
                if (SelectedInfo.CurrentFolder.Details.UID == SelectedFolder.Details.UID)
                    SelectedInfo.ShowItem(SelectedFolder, null);
                else
                    SelectedInfo.ShowDefault();
            }
             * */

            bool infoSet = false;
            string infoPath = SelectedInfo.CurrentPath;

            SelectedFolder = folder;
            folder.Selected = true;

            string dirpath = null;
            if (Working != null)
                dirpath = Working.RootPath + folder.GetPath();

            ulong selectedUID = 0;
            if (SelectedInfo.CurrentItem != null)
                selectedUID = SelectedInfo.CurrentItem.UID;

            FileListView.Items.Clear();
            FileListView.SmallImageList = FileIcons;

            // add sub folders
            if (!FoldersButton.Checked && folder.Parent.GetType() == typeof(FolderNode))
            {
                FileItem dots = new FileItem(this, new FolderNode(this, new StorageFolder(), folder.Parent, false));
                dots.Folder.Details.Name = "..";
                dots.Text = "..";

                if (string.Compare("..", infoPath, true) == 0)
                {
                    infoSet = true;
                    dots.Selected = true;
                    SelectedInfo.ShowDots();
                }

                FileListView.Items.Add(dots);
            }

            foreach (FolderNode sub in folder.Nodes)
            {
                FileItem subItem = new FileItem(this, sub);

                if (string.Compare(sub.GetPath(), infoPath, true) == 0)
                {
                    infoSet = true;
                    subItem.Selected = true;
                    SelectedInfo.ShowItem(sub, null);
                }

                FileListView.Items.Add(subItem);
            }

            // if folder unlocked, add untracked folders, mark temp
            if(folder.Details.IsFlagged(StorageFlags.Unlocked) && Directory.Exists(dirpath))
                try
                {
                    foreach (string dir in Directory.GetDirectories(dirpath))
                    {
                        string name = Path.GetFileName(dir);

                        if (name.CompareTo(".history") == 0)
                            continue;

                        if (folder.GetFolder(name) != null)
                            continue;

                        StorageFolder details = new StorageFolder();
                        details.Name = name;

                        FileItem tempFolder = new FileItem(this, new FolderNode(this, details, folder, true));

                        if (string.Compare(tempFolder.GetPath(), infoPath, true) == 0)
                        {
                            infoSet = true;
                            tempFolder.Selected = true;
                            SelectedInfo.ShowItem(tempFolder.Folder, null);
                        }

                        FileListView.Items.Add(tempFolder);
                    }
                }
                catch { }

            // add tracked files
            foreach (FileItem file in folder.Files.Values)
                if (!file.Details.IsFlagged(StorageFlags.Archived) || GhostsButton.Checked)
                {
                    if (string.Compare(file.GetPath(), infoPath, true) == 0)
                    {
                        infoSet = true;
                        file.Selected = true;
                        SelectedInfo.ShowItem(folder, file);
                    }
                    else
                        file.Selected = false;

                    FileListView.Items.Add(file);
                }

            // if folder unlocked, add untracked files, mark temp
            if (folder.Details.IsFlagged(StorageFlags.Unlocked) && Directory.Exists(dirpath))
                try
                {
                    foreach (string filepath in Directory.GetFiles(dirpath))
                    {
                        string name = Path.GetFileName(filepath);

                        if (folder.GetFile(name) != null)
                            continue;

                        StorageFile details = new StorageFile();
                        details.Name = name;
                        details.InternalSize = new FileInfo(filepath).Length;

                        FileItem tempFile = new FileItem(this, folder, details, true);

                        if (string.Compare(tempFile.GetPath(), infoPath, true) == 0)
                        {
                            infoSet = true;
                            tempFile.Selected = true;
                            SelectedInfo.ShowItem(folder, tempFile);
                        }

                        FileListView.Items.Add(tempFile);
                    }
                }
                catch { }

            UpdateListItems();

            if (!infoSet && SelectedFolder.GetPath() == infoPath)
            {
                infoSet = true;
                SelectedInfo.ShowItem(SelectedFolder, null);
            }
            if (!infoSet)
                SelectedInfo.ShowDiffs();
        }
Exemple #24
0
        public void Modify(DateTime time, StorageFile newInfo)
        {
            // Details is mirror of file in working folder, it can change multiple times before the user commits, archive the
            //   original info when the user starts messing with stuff, only once, dont want to archive stuff not accessible on the network

            if (Info.IsFlagged(StorageFlags.Modified))
            {
                Info = newInfo;
                Archived.SafeRemoveFirst();
                Archived.SafeAddFirst(newInfo);
            }
            else
            {
                Archived.SafeAddFirst(newInfo);
                Info = newInfo;
            }

            Info.SetFlag(StorageFlags.Modified);
            Info.Date = time.ToUniversalTime();
        }
Exemple #25
0
        public void TrackFile(string path, StorageFile track)
        {
            LocalFolder folder = GetLocalFolder(path);

            if (folder == null)
                return;

            // increase references
            OpFile commonFile = null;
            if (Storages.FileMap.SafeTryGetValue(track.HashID, out commonFile))
                commonFile.References++;

            LocalFile file = new LocalFile(track);
            file.Info.SetFlag(StorageFlags.Modified);
            file.Archived.SafeAddFirst(track);

            folder.AddFile(file);

            Modified = true;
            PeriodicSave = true;

            Storages.CallFileUpdate(ProjectID, folder.GetPath(), file.Info.UID, WorkingChange.Created);
        }
Exemple #26
0
        public void UnintegrateFile(string path, ulong who, StorageFile change)
        {
            // put file in local's integration map for this user id

            LocalFolder folder = GetLocalFolder(path);
            LocalFile file = null;

            if (!folder.Files.SafeTryGetValue(change.UID, out file))
                return;

            file.Integrated.SafeRemove(who);

            Modified = true;
            PeriodicSave = true;

            Storages.CallFileUpdate(ProjectID, path, file.Info.UID, WorkingChange.Updated);
        }
Exemple #27
0
        public static StorageFile Decode(G2Header root)
        {
            StorageFile file = new StorageFile();
            G2Header child = new G2Header(root.Data);

            while (G2Protocol.ReadNextChild(root, child) == G2ReadResult.PACKET_GOOD)
            {
                if (!G2Protocol.ReadPayload(child))
                    continue;

                switch (child.Name)
                {
                    case Packet_UID:
                        file.UID = BitConverter.ToUInt64(child.Data, child.PayloadPos);
                        break;

                    case Packet_Name:
                        file.Name = UTF8Encoding.UTF8.GetString(child.Data, child.PayloadPos, child.PayloadSize);
                        break;

                    case Packet_Date:
                        file.Date = DateTime.FromBinary(BitConverter.ToInt64(child.Data, child.PayloadPos));
                        break;

                    case Packet_Flags:
                        file.Flags = (StorageFlags) BitConverter.ToUInt16(child.Data, child.PayloadPos);
                        break;

                    case Packet_Note:
                        file.Note = UTF8Encoding.UTF8.GetString(child.Data, child.PayloadPos, child.PayloadSize);
                        break;

                    case Packet_Revs:
                        file.Revs = child.Data[child.PayloadPos];
                        break;

                    case Packet_Size:
                        file.Size = CompactNum.ToInt64(child.Data, child.PayloadPos, child.PayloadSize);
                        break;

                    case Packet_Hash:
                        file.Hash = Utilities.ExtractBytes(child.Data, child.PayloadPos, child.PayloadSize);
                        file.HashID = BitConverter.ToUInt64(file.Hash, 0);
                        break;

                    case Packet_FileKey:
                        file.FileKey = Utilities.ExtractBytes(child.Data, child.PayloadPos, child.PayloadSize);
                        break;

                    case Packet_InternalSize:
                        file.InternalSize = CompactNum.ToInt64(child.Data, child.PayloadPos, child.PayloadSize);
                        break;

                    case Packet_InternalHash:
                        file.InternalHash = Utilities.ExtractBytes(child.Data, child.PayloadPos, child.PayloadSize);
                        file.InternalHashID = BitConverter.ToUInt64(file.InternalHash, 0);
                        break;

                    case Packet_Integrated:
                        file.IntegratedID = BitConverter.ToUInt64(child.Data, child.PayloadPos);
                        break;

                    case Packet_Scope:
                        file.Scope[BitConverter.ToUInt64(child.Data, child.PayloadPos)] = BitConverter.ToInt16(child.Data, child.PayloadPos + 8);
                        break;
                }
            }

            return file;
        }
Exemple #28
0
        public ComboFileItem(DiffForm diff, ulong id, StorageFile file)
        {
            File = file;
            ID = id;

            if (id == 0)
                Text = file.Date.ToLocalTime().ToString();
            else
                Text = diff.Core.GetName(id);

            if (Utilities.MemCompare(file.InternalHash, diff.Target.InternalHash))
                Text += " (Identical)";
            else if(!diff.Info.Storages.FileExists(file) )
                Text += " (Unavailable)";
        }