public CacheManagerStreamWriter(out KeyCollection keys, int blockLength, HashAlgorithm hashAlgorithm, CacheManager cacheManager, BufferManager bufferManager)
 {
     keys               = _keyList;
     _hashAlgorithm     = hashAlgorithm;
     _cacheManager      = cacheManager;
     _bufferManager     = bufferManager;
     _blockBuffer       = bufferManager.TakeBuffer(blockLength);
     _blockBufferLength = blockLength;
 }
Beispiel #2
0
        public CacheManagerStreamReader(KeyCollection keys, CacheManager cacheManager, BufferManager bufferManager)
        {
            _cacheManager  = cacheManager;
            _keys          = keys;
            _bufferManager = bufferManager;

            _blockBuffer = _cacheManager[_keys[_keysIndex]];
            _keysIndex++;

            _length = keys.Sum(n => (long)cacheManager.GetLength(n));
        }
Beispiel #3
0
        private void EncodeManagerThread()
        {
            for (; ;)
            {
                Thread.Sleep(1000 * 1);
                if (this.EncodeState == ManagerState.Stop)
                {
                    return;
                }

                UploadItem item = null;

                try
                {
                    lock (this.ThisLock)
                    {
                        if (_settings.UploadItems.Count > 0)
                        {
                            item = _settings.UploadItems
                                   .Where(n => n.State == UploadState.ComputeHash || n.State == UploadState.Encoding || n.State == UploadState.ParityEncoding)
                                   .Where(n => n.Priority != 0)
                                   .OrderBy(n => - n.Priority)
                                   .Where(n => !_workingPaths.Contains(n.FilePath))
                                   .FirstOrDefault();

                            if (item != null)
                            {
                                _workingPaths.Add(item.FilePath);
                            }
                        }
                    }
                }
                catch (Exception)
                {
                    return;
                }

                if (item == null)
                {
                    continue;
                }

                try
                {
                    if (item.Type == UploadType.Upload)
                    {
                        if (item.Groups.Count == 0 && item.Keys.Count == 0)
                        {
                            item.State = UploadState.Encoding;

                            KeyCollection keys      = null;
                            byte[]        cryptoKey = null;

                            try
                            {
                                using (FileStream stream = new FileStream(item.FilePath, FileMode.Open, FileAccess.Read, FileShare.Read))
                                    using (ProgressStream hashProgressStream = new ProgressStream(stream, (object sender, long readSize, long writeSize, out bool isStop) =>
                                    {
                                        isStop = (this.EncodeState == ManagerState.Stop || !_settings.UploadItems.Contains(item));

                                        item.EncodingBytes = Math.Min(readSize, stream.Length);
                                    }, 1024 * 1024, true))
                                        using (ProgressStream encodingProgressStream = new ProgressStream(stream, (object sender, long readSize, long writeSize, out bool isStop) =>
                                        {
                                            isStop = (this.EncodeState == ManagerState.Stop || !_settings.UploadItems.Contains(item));

                                            item.EncodingBytes = Math.Min(readSize, stream.Length);
                                        }, 1024 * 1024, true))
                                        {
                                            item.EncodeBytes = stream.Length;
                                            item.Seed.Length = stream.Length;

                                            if (item.Seed.Length == 0)
                                            {
                                                throw new InvalidOperationException("Stream Length");
                                            }

                                            item.State = UploadState.ComputeHash;

                                            if (item.HashAlgorithm == HashAlgorithm.Sha256)
                                            {
                                                cryptoKey = Sha256.ComputeHash(hashProgressStream);
                                            }

                                            stream.Seek(0, SeekOrigin.Begin);
                                            item.EncodingBytes = 0;

                                            item.State = UploadState.Encoding;
                                            keys       = _cacheManager.Encoding(encodingProgressStream, item.CompressionAlgorithm, item.CryptoAlgorithm, cryptoKey, item.BlockLength, item.HashAlgorithm);
                                        }
                            }
                            catch (StopIoException)
                            {
                                continue;
                            }

                            lock (this.ThisLock)
                            {
                                foreach (var key in keys)
                                {
                                    item.UploadKeys.Add(key);
                                    item.LockedKeys.Add(key);
                                }

                                item.EncodingBytes = 0;
                                item.EncodeBytes   = 0;

                                item.CryptoKey = cryptoKey;
                                item.Keys.AddRange(keys);
                            }
                        }
                        else if (item.Groups.Count == 0 && item.Keys.Count == 1)
                        {
                            lock (this.ThisLock)
                            {
                                item.Seed.Rank = item.Rank;
                                item.Seed.Key  = item.Keys[0];
                                item.Keys.Clear();

                                item.Seed.CompressionAlgorithm = item.CompressionAlgorithm;

                                item.Seed.CryptoAlgorithm = item.CryptoAlgorithm;
                                item.Seed.CryptoKey       = item.CryptoKey;

                                if (item.DigitalSignature != null)
                                {
                                    item.Seed.CreateCertificate(item.DigitalSignature);
                                }

                                item.UploadKeys.Add(item.Seed.Key);

                                foreach (var key in item.UploadKeys)
                                {
                                    _connectionsManager.Upload(key);
                                }

                                this.CheckState(item);

                                _cacheManager.SetSeed(item.Seed.Clone(), item.Indexes.Select(n => n.Clone()).ToArray());
                                item.Indexes.Clear();

                                foreach (var key in item.LockedKeys)
                                {
                                    _cacheManager.Unlock(key);
                                }

                                item.LockedKeys.Clear();

                                item.State = UploadState.Uploading;
                            }
                        }
                        else if (item.Keys.Count > 0)
                        {
                            item.State = UploadState.ParityEncoding;

                            item.EncodeBytes = item.Groups.Sum(n =>
                            {
                                long sumLength = 0;

                                for (int i = 0; i < n.InformationLength; i++)
                                {
                                    if (_cacheManager.Contains(n.Keys[i]))
                                    {
                                        sumLength += (long)_cacheManager.GetLength(n.Keys[i]);
                                    }
                                }

                                return(sumLength);
                            }) + item.Keys.Sum(n =>
                            {
                                if (_cacheManager.Contains(n))
                                {
                                    return((long)_cacheManager.GetLength(n));
                                }

                                return(0);
                            });

                            var   length = Math.Min(item.Keys.Count, 128);
                            var   keys   = new KeyCollection(item.Keys.Take(length));
                            Group group  = null;

                            try
                            {
                                group = _cacheManager.ParityEncoding(keys, item.HashAlgorithm, item.BlockLength, item.CorrectionAlgorithm, (object state2) =>
                                {
                                    return(this.EncodeState == ManagerState.Stop || !_settings.UploadItems.Contains(item));
                                });
                            }
                            catch (StopException)
                            {
                                continue;
                            }

                            lock (this.ThisLock)
                            {
                                foreach (var key in group.Keys.Skip(group.InformationLength))
                                {
                                    item.UploadKeys.Add(key);
                                    item.LockedKeys.Add(key);
                                }

                                item.Groups.Add(group);

                                item.EncodingBytes = item.Groups.Sum(n =>
                                {
                                    long sumLength = 0;

                                    for (int i = 0; i < n.InformationLength; i++)
                                    {
                                        if (_cacheManager.Contains(n.Keys[i]))
                                        {
                                            sumLength += (long)_cacheManager.GetLength(n.Keys[i]);
                                        }
                                    }

                                    return(sumLength);
                                });

                                item.Keys.RemoveRange(0, length);
                            }
                        }
                        else if (item.Groups.Count > 0 && item.Keys.Count == 0)
                        {
                            item.State = UploadState.Encoding;

                            var index = new Index();
                            index.Groups.AddRange(item.Groups);
                            index.CompressionAlgorithm = item.CompressionAlgorithm;
                            index.CryptoAlgorithm      = item.CryptoAlgorithm;
                            index.CryptoKey            = item.CryptoKey;

                            item.Indexes.Add(index);

                            byte[]        cryptoKey = null;
                            KeyCollection keys      = null;

                            try
                            {
                                using (var stream = index.Export(_bufferManager))
                                    using (ProgressStream hashProgressStream = new ProgressStream(stream, (object sender, long readSize, long writeSize, out bool isStop) =>
                                    {
                                        isStop = (this.EncodeState == ManagerState.Stop || !_settings.UploadItems.Contains(item));

                                        item.EncodingBytes = Math.Min(readSize, stream.Length);
                                    }, 1024 * 1024, true))
                                        using (ProgressStream encodingProgressStream = new ProgressStream(stream, (object sender, long readSize, long writeSize, out bool isStop) =>
                                        {
                                            isStop = (this.EncodeState == ManagerState.Stop || !_settings.UploadItems.Contains(item));

                                            item.EncodingBytes = Math.Min(readSize, stream.Length);
                                        }, 1024 * 1024, true))
                                        {
                                            item.EncodeBytes = stream.Length;

                                            item.State = UploadState.ComputeHash;

                                            if (item.HashAlgorithm == HashAlgorithm.Sha256)
                                            {
                                                cryptoKey = Sha256.ComputeHash(hashProgressStream);
                                            }

                                            stream.Seek(0, SeekOrigin.Begin);
                                            item.EncodingBytes = 0;

                                            item.State = UploadState.Encoding;
                                            keys       = _cacheManager.Encoding(encodingProgressStream, item.CompressionAlgorithm, item.CryptoAlgorithm, cryptoKey, item.BlockLength, item.HashAlgorithm);
                                        }
                            }
                            catch (StopIoException)
                            {
                                continue;
                            }

                            lock (this.ThisLock)
                            {
                                foreach (var key in keys)
                                {
                                    item.UploadKeys.Add(key);
                                    item.LockedKeys.Add(key);
                                }

                                item.EncodingBytes = 0;
                                item.EncodeBytes   = 0;

                                item.CryptoKey = cryptoKey;
                                item.Keys.AddRange(keys);
                                item.Rank++;
                                item.Groups.Clear();
                            }
                        }
                    }
                    else if (item.Type == UploadType.Share)
                    {
                        if (item.Groups.Count == 0 && item.Keys.Count == 0)
                        {
                            item.State = UploadState.ComputeHash;

                            KeyCollection keys = null;

                            try
                            {
                                using (FileStream stream = new FileStream(item.FilePath, FileMode.Open, FileAccess.Read, FileShare.Read))
                                    using (ProgressStream hashProgressStream = new ProgressStream(stream, (object sender, long readSize, long writeSize, out bool isStop) =>
                                    {
                                        isStop = (this.EncodeState == ManagerState.Stop || !_settings.UploadItems.Contains(item));

                                        item.EncodingBytes = Math.Min(readSize, stream.Length);
                                    }, 1024 * 1024, true))
                                    {
                                        item.EncodeBytes = stream.Length;
                                        item.Seed.Length = stream.Length;

                                        if (item.Seed.Length == 0)
                                        {
                                            throw new InvalidOperationException("Stream Length");
                                        }

                                        keys = _cacheManager.Share(hashProgressStream, stream.Name, item.HashAlgorithm, item.BlockLength);
                                    }
                            }
                            catch (StopIoException)
                            {
                                continue;
                            }

                            if (keys.Count == 1)
                            {
                                lock (this.ThisLock)
                                {
                                    item.EncodingBytes = 0;
                                    item.EncodeBytes   = 0;

                                    item.Keys.Add(keys[0]);

                                    item.State = UploadState.Encoding;
                                }
                            }
                            else
                            {
                                var groups = new List <Group>();

                                for (int i = 0, remain = keys.Count; 0 < remain; i++, remain -= 256)
                                {
                                    var tempKeys = keys.GetRange(i * 256, Math.Min(remain, 256));

                                    Group group = new Group();
                                    group.CorrectionAlgorithm = CorrectionAlgorithm.None;
                                    group.InformationLength   = tempKeys.Count;
                                    group.BlockLength         = item.BlockLength;
                                    group.Length = tempKeys.Sum(n => (long)_cacheManager.GetLength(n));
                                    group.Keys.AddRange(tempKeys);

                                    groups.Add(group);
                                }

                                lock (this.ThisLock)
                                {
                                    item.EncodingBytes = 0;
                                    item.EncodeBytes   = 0;

                                    foreach (var key in keys)
                                    {
                                        item.UploadKeys.Add(key);
                                    }

                                    item.Groups.AddRange(groups);

                                    item.State = UploadState.Encoding;
                                }
                            }
                        }
                        else if (item.Groups.Count == 0 && item.Keys.Count == 1)
                        {
                            lock (this.ThisLock)
                            {
                                item.Seed.Rank = item.Rank;
                                item.Seed.Key  = item.Keys[0];
                                item.Keys.Clear();

                                if (item.Rank != 1)
                                {
                                    item.Seed.CompressionAlgorithm = item.CompressionAlgorithm;

                                    item.Seed.CryptoAlgorithm = item.CryptoAlgorithm;
                                    item.Seed.CryptoKey       = item.CryptoKey;
                                }

                                if (item.DigitalSignature != null)
                                {
                                    item.Seed.CreateCertificate(item.DigitalSignature);
                                }

                                item.UploadKeys.Add(item.Seed.Key);

                                foreach (var key in item.UploadKeys)
                                {
                                    _connectionsManager.Upload(key);
                                }

                                this.CheckState(item);

                                _cacheManager.SetSeed(item.Seed.Clone(), item.FilePath, item.Indexes.Select(n => n.Clone()).ToArray());
                                item.Indexes.Clear();

                                foreach (var key in item.LockedKeys)
                                {
                                    _cacheManager.Unlock(key);
                                }

                                item.LockedKeys.Clear();

                                item.State = UploadState.Uploading;
                            }
                        }
                        else if (item.Keys.Count > 0)
                        {
                            item.State = UploadState.ParityEncoding;

                            item.EncodeBytes = item.Groups.Sum(n =>
                            {
                                long sumLength = 0;

                                for (int i = 0; i < n.InformationLength; i++)
                                {
                                    if (_cacheManager.Contains(n.Keys[i]))
                                    {
                                        sumLength += (long)_cacheManager.GetLength(n.Keys[i]);
                                    }
                                }

                                return(sumLength);
                            }) + item.Keys.Sum(n =>
                            {
                                if (_cacheManager.Contains(n))
                                {
                                    return((long)_cacheManager.GetLength(n));
                                }

                                return(0);
                            });

                            var   length = Math.Min(item.Keys.Count, 128);
                            var   keys   = new KeyCollection(item.Keys.Take(length));
                            Group group  = null;

                            try
                            {
                                group = _cacheManager.ParityEncoding(keys, item.HashAlgorithm, item.BlockLength, item.CorrectionAlgorithm, (object state2) =>
                                {
                                    return(this.EncodeState == ManagerState.Stop || !_settings.UploadItems.Contains(item));
                                });
                            }
                            catch (StopException)
                            {
                                continue;
                            }

                            lock (this.ThisLock)
                            {
                                foreach (var key in group.Keys.Skip(group.InformationLength))
                                {
                                    item.UploadKeys.Add(key);
                                    item.LockedKeys.Add(key);
                                }

                                item.Groups.Add(group);

                                item.EncodingBytes = item.Groups.Sum(n =>
                                {
                                    long sumLength = 0;

                                    for (int i = 0; i < n.InformationLength; i++)
                                    {
                                        if (_cacheManager.Contains(n.Keys[i]))
                                        {
                                            sumLength += (long)_cacheManager.GetLength(n.Keys[i]);
                                        }
                                    }

                                    return(sumLength);
                                });

                                item.Keys.RemoveRange(0, length);
                            }
                        }
                        else if (item.Groups.Count > 0 && item.Keys.Count == 0)
                        {
                            item.State = UploadState.Encoding;

                            var index = new Index();
                            index.Groups.AddRange(item.Groups);

                            if (item.Rank != 1)
                            {
                                index.CompressionAlgorithm = item.CompressionAlgorithm;

                                index.CryptoAlgorithm = item.CryptoAlgorithm;
                                index.CryptoKey       = item.CryptoKey;

                                item.Indexes.Add(index);
                            }

                            byte[]        cryptoKey = null;
                            KeyCollection keys      = null;

                            try
                            {
                                using (var stream = index.Export(_bufferManager))
                                    using (ProgressStream hashProgressStream = new ProgressStream(stream, (object sender, long readSize, long writeSize, out bool isStop) =>
                                    {
                                        isStop = (this.EncodeState == ManagerState.Stop || !_settings.UploadItems.Contains(item));

                                        item.EncodingBytes = Math.Min(readSize, stream.Length);
                                    }, 1024 * 1024, true))
                                        using (ProgressStream encodingProgressStream = new ProgressStream(stream, (object sender, long readSize, long writeSize, out bool isStop) =>
                                        {
                                            isStop = (this.EncodeState == ManagerState.Stop || !_settings.UploadItems.Contains(item));

                                            item.EncodingBytes = Math.Min(readSize, stream.Length);
                                        }, 1024 * 1024, true))
                                        {
                                            item.EncodeBytes = stream.Length;

                                            item.State = UploadState.ComputeHash;

                                            if (item.HashAlgorithm == HashAlgorithm.Sha256)
                                            {
                                                cryptoKey = Sha256.ComputeHash(hashProgressStream);
                                            }

                                            stream.Seek(0, SeekOrigin.Begin);
                                            item.EncodingBytes = 0;

                                            item.State = UploadState.Encoding;
                                            keys       = _cacheManager.Encoding(encodingProgressStream, item.CompressionAlgorithm, item.CryptoAlgorithm, cryptoKey, item.BlockLength, item.HashAlgorithm);
                                        }
                            }
                            catch (StopIoException)
                            {
                                continue;
                            }

                            lock (this.ThisLock)
                            {
                                foreach (var key in keys)
                                {
                                    item.UploadKeys.Add(key);
                                    item.LockedKeys.Add(key);
                                }

                                item.EncodingBytes = 0;
                                item.EncodeBytes   = 0;

                                item.CryptoKey = cryptoKey;
                                item.Keys.AddRange(keys);
                                item.Rank++;

                                item.Groups.Clear();
                            }
                        }
                    }
                }
                catch (Exception e)
                {
                    item.State = UploadState.Error;

                    Log.Error(e);
                }
                finally
                {
                    _workingPaths.Remove(item.FilePath);
                }
            }
        }
Beispiel #4
0
        private void UploadManagerThread()
        {
            for (; ;)
            {
                Thread.Sleep(1000 * 1);
                if (this.State == ManagerState.Stop)
                {
                    return;
                }

                BackgroundUploadItem item = null;

                try
                {
                    lock (this.ThisLock)
                    {
                        if (_settings.BackgroundUploadItems.Count > 0)
                        {
                            item = _settings.BackgroundUploadItems
                                   .Where(n => n.State == BackgroundUploadState.Encoding)
                                   .FirstOrDefault();
                        }
                    }
                }
                catch (Exception)
                {
                    return;
                }

                if (item == null)
                {
                    continue;
                }

                try
                {
                    if (item.Groups.Count == 0 && item.Keys.Count == 0)
                    {
                        Stream stream = null;

                        try
                        {
                            if (item.Type == BackgroundItemType.Link)
                            {
                                var link = item.Value as Link;
                                if (link == null)
                                {
                                    throw new FormatException();
                                }

                                stream = link.Export(_bufferManager);
                            }
                            else if (item.Type == BackgroundItemType.Store)
                            {
                                var store = item.Value as Store;
                                if (store == null)
                                {
                                    throw new FormatException();
                                }

                                stream = store.Export(_bufferManager);
                            }
                            else
                            {
                                throw new FormatException();
                            }

                            if (stream.Length == 0)
                            {
                                lock (this.ThisLock)
                                {
                                    item.Seed.Rank = 0;

                                    if (item.DigitalSignature != null)
                                    {
                                        item.Seed.CreateCertificate(item.DigitalSignature);
                                    }

                                    _connectionsManager.Upload(item.Seed);

                                    item.State = BackgroundUploadState.Completed;
                                }
                            }
                            else
                            {
                                KeyCollection keys      = null;
                                byte[]        cryptoKey = null;

                                try
                                {
                                    using (ProgressStream encodingProgressStream = new ProgressStream(stream, (object sender, long readSize, long writeSize, out bool isStop) =>
                                    {
                                        isStop = (this.State == ManagerState.Stop || !_settings.BackgroundUploadItems.Contains(item));
                                    }, 1024 * 1024, true))
                                    {
                                        item.Seed.Length = stream.Length;

                                        if (item.Seed.Length == 0)
                                        {
                                            throw new InvalidOperationException("Stream Length");
                                        }

                                        if (item.HashAlgorithm == HashAlgorithm.Sha256)
                                        {
                                            cryptoKey = Sha256.ComputeHash(encodingProgressStream);
                                        }

                                        encodingProgressStream.Seek(0, SeekOrigin.Begin);

                                        item.State = BackgroundUploadState.Encoding;
                                        keys       = _cacheManager.Encoding(encodingProgressStream, item.CompressionAlgorithm, item.CryptoAlgorithm, cryptoKey, item.BlockLength, item.HashAlgorithm);
                                    }
                                }
                                catch (StopIoException)
                                {
                                    continue;
                                }

                                lock (this.ThisLock)
                                {
                                    foreach (var key in keys)
                                    {
                                        item.UploadKeys.Add(key);
                                        item.LockedKeys.Add(key);
                                    }

                                    item.CryptoKey = cryptoKey;
                                    item.Keys.AddRange(keys);
                                }
                            }
                        }
                        finally
                        {
                            if (stream != null)
                            {
                                stream.Dispose();
                            }
                        }
                    }
                    else if (item.Groups.Count == 0 && item.Keys.Count == 1)
                    {
                        lock (this.ThisLock)
                        {
                            item.Seed.Rank = item.Rank;
                            item.Seed.Key  = item.Keys[0];
                            item.Keys.Clear();

                            item.Seed.CompressionAlgorithm = item.CompressionAlgorithm;

                            item.Seed.CryptoAlgorithm = item.CryptoAlgorithm;
                            item.Seed.CryptoKey       = item.CryptoKey;

                            if (item.DigitalSignature != null)
                            {
                                item.Seed.CreateCertificate(item.DigitalSignature);
                            }

                            item.UploadKeys.Add(item.Seed.Key);

                            foreach (var key in item.UploadKeys)
                            {
                                _connectionsManager.Upload(key);
                            }

                            this.SetKeyCount(item);

                            foreach (var key in item.LockedKeys)
                            {
                                _cacheManager.Unlock(key);
                            }

                            item.LockedKeys.Clear();

                            item.State = BackgroundUploadState.Uploading;

                            _connectionsManager.Upload(item.Seed);
                        }
                    }
                    else if (item.Keys.Count > 0)
                    {
                        var   length = Math.Min(item.Keys.Count, 128);
                        var   keys   = new KeyCollection(item.Keys.Take(length));
                        Group group  = null;

                        try
                        {
                            group = _cacheManager.ParityEncoding(keys, item.HashAlgorithm, item.BlockLength, item.CorrectionAlgorithm, (object state2) =>
                            {
                                return(this.State == ManagerState.Stop || !_settings.BackgroundUploadItems.Contains(item));
                            });
                        }
                        catch (StopException)
                        {
                            continue;
                        }

                        lock (this.ThisLock)
                        {
                            foreach (var key in group.Keys.Skip(group.InformationLength))
                            {
                                item.UploadKeys.Add(key);
                                item.LockedKeys.Add(key);
                            }

                            item.Groups.Add(group);

                            item.Keys.RemoveRange(0, length);
                        }
                    }
                    else if (item.Groups.Count > 0 && item.Keys.Count == 0)
                    {
                        var index = new Index();
                        index.Groups.AddRange(item.Groups);
                        index.CompressionAlgorithm = item.CompressionAlgorithm;
                        index.CryptoAlgorithm      = item.CryptoAlgorithm;
                        index.CryptoKey            = item.CryptoKey;

                        byte[]        cryptoKey = null;
                        KeyCollection keys      = null;

                        try
                        {
                            using (var stream = index.Export(_bufferManager))
                                using (ProgressStream encodingProgressStream = new ProgressStream(stream, (object sender, long readSize, long writeSize, out bool isStop) =>
                                {
                                    isStop = (this.State == ManagerState.Stop || !_settings.BackgroundUploadItems.Contains(item));
                                }, 1024 * 1024, true))
                                {
                                    if (item.HashAlgorithm == HashAlgorithm.Sha256)
                                    {
                                        cryptoKey = Sha256.ComputeHash(encodingProgressStream);
                                    }

                                    encodingProgressStream.Seek(0, SeekOrigin.Begin);

                                    item.State = BackgroundUploadState.Encoding;
                                    keys       = _cacheManager.Encoding(encodingProgressStream, item.CompressionAlgorithm, item.CryptoAlgorithm, cryptoKey, item.BlockLength, item.HashAlgorithm);
                                }
                        }
                        catch (StopIoException)
                        {
                            continue;
                        }

                        lock (this.ThisLock)
                        {
                            foreach (var key in keys)
                            {
                                item.UploadKeys.Add(key);
                                item.LockedKeys.Add(key);
                            }

                            item.CryptoKey = cryptoKey;
                            item.Keys.AddRange(keys);
                            item.Rank++;
                            item.Groups.Clear();
                        }
                    }
                }
                catch (Exception e)
                {
                    item.State = BackgroundUploadState.Error;

                    Log.Error(e);

                    this.Remove(item);
                }
            }
        }