Synnefo » Pithos MS Client

        private TaskCompletionSource<bool> _tcs;

        private readonly AsyncManualResetEvent _pauseAgent = new AsyncManualResetEvent(true);

                    _pauseAgent.Wait();

            /*

                Action loop = null;

                loop = () =>

                            {

                                var message = inbox.Receive();

                                var process = message.Then(ProcessDelete,inbox.CancellationToken);

                                inbox.LoopAsync(process, loop);

                            };

                loop();

*/

        private async Task ProcessDelete(CloudDeleteAction action)

                        _pauseAgent.Reset();

                        _pauseAgent.Set();

            _pauseAgent.Wait();

       /* class ObjectInfoByNameComparer:IEqualityComparer<ObjectInfo>

        {

            public bool Equals(ObjectInfo x, ObjectInfo y)

            {

                return x.Name.Equals(y.Name,StringComparison.InvariantCultureIgnoreCase);

            }

            public int GetHashCode(ObjectInfo obj)

            {

                return obj.Name.ToLower().GetHashCode();

            }

        }*/

        {             

            if (_tcs!=null)

                _tcs.TrySetResult(true);

            else

            {

                //TODO: This may be OK for testing purposes, but we have no guarantee that it will

                //work properly in production

                PollRemoteFiles(repeat:false);

            }

        public async Task PollRemoteFiles(DateTime? since = null,bool repeat=true)

                    DateTime current = DateTime.Now.AddSeconds(-1);

                    if (repeat)

                        nextSince = current;

                    else

                        return;

                //Wait for the polling interval to pass or the Manual flat to be toggled

        {            

            _tcs = new TaskCompletionSource<bool>();

            var signaledTask = await TaskEx.WhenAny(_tcs.Task, wait);

                await _pauseAgent.WaitAsync();

                    await _pauseAgent.WaitAsync();

                        //TODO: Change the way deleted objects are detected.

                        //The list operation returns all existing objects so we could detect deleted remote objects

                        //by detecting objects that exist only locally. There are several cases where this is NOT the case:

                        //1.    The first time the application runs, as there may be files that were added while 

                        //      the application was down.

                        //2.    An object that is currently being uploaded will not appear in the remote list

                        //      until the upload finishes.

                        //      SOLUTION 1: Check the upload/download queue for the file

                        //      SOLUTION 2: Check the SQLite states for the file's entry. If it is being uploaded, 

                        //          or its last modification was after the current poll, don't delete it. This way we don't

                        //          delete objects whose upload finished too late to be included in the list.

                        //We need to detect and protect against such situations

                        //TODO: Does FileState have a LastModification field?

                        //TODO: How do we update the LastModification field? Do we need to add SQLite triggers?

                        //      Do we need to use a proper SQLite schema?

                        //      We can create a trigger with 

                        // CREATE TRIGGER IF NOT EXISTS update_last_modified UPDATE ON FileState FOR EACH ROW

                        //  BEGIN

                        //      UPDATE FileState SET LastModification=datetime('now')  WHERE Id=old.Id;

                        //  END;

                        //

                        //NOTE: Some files may have been deleted remotely while the application was down. 

                        //  We DO have to delete those files. Checking the trash makes it easy to detect them,

                        //  Otherwise, we can't be really sure whether we need to upload or delete 

                        //  the local-only files.

                        //  SOLUTION 1: Ask the user when such a local-only file is detected during the first poll.

                        //  SOLUTION 2: Mark conflict and ask the user as in #1

                        //var relativePath = objectInfo.RelativeUrlToFilePath(accountInfo.UserName);

/*

        Dictionary<string, List<ObjectInfo>> _currentSnapshot = new Dictionary<string, List<ObjectInfo>>();

        Dictionary<string, List<ObjectInfo>> _previousSnapshot = new Dictionary<string, List<ObjectInfo>>();

*/

                        //Try to acquire a gate on the file, to take into account files that have been dequeued

                        //and are being processed

                        //TODO: The gate is not enough. Perhaps we need to keep a journal of processed files and check against

                        //that as well.

/*

                        using (var gate = NetworkGate.Acquire(item.FullName, NetworkOperation.Deleting))

                            if (gate.Failed)

                                continue;

*/

                            if ((item.Attributes & FileAttributes.ReadOnly) == FileAttributes.ReadOnly)

                            {

                                item.Attributes = item.Attributes & ~FileAttributes.ReadOnly;

                            }

                            item.Delete();

                            DateTime lastDate;

                            _lastSeen.TryRemove(item.FullName, out lastDate);

                            deletedFiles.Add(item);

/*

*/

                        //FileState.FindByFilePath(localFile.FullName);

        //Creates an appropriate action for each server file

/*

        private IEnumerable<CloudAction> ObjectsToActions(AccountInfo accountInfo,IEnumerable<ObjectInfo> remote)

        {

            if (remote==null)

                throw new ArgumentNullException();

            Contract.EndContractBlock();

            var fileAgent = GetFileAgent(accountInfo);

            //In order to avoid multiple iterations over the files, we iterate only once

            //over the remote files

            foreach (var objectInfo in remote)

            {

                var relativePath = objectInfo.RelativeUrlToFilePath(accountInfo.UserName);

                //and remove any matching objects from the list, adding them to the commonObjects list

                if (fileAgent.Exists(relativePath))

                {

                    //If a directory object already exists, we don't need to perform any other action                    

                    var localFile = fileAgent.GetFileSystemInfo(relativePath);

                    if (objectInfo.Content_Type == @"application/directory" && localFile is DirectoryInfo)

                        continue;

                    using (new SessionScope(FlushAction.Never))

                    {

                        var state =  StatusKeeper.GetStateByFilePath(localFile.FullName);

                        _lastSeen[localFile.FullName] = DateTime.Now;

                        //FileState.FindByFilePath(localFile.FullName);

                        //Common files should be checked on a per-case basis to detect differences, which is newer

                        yield return new CloudAction(accountInfo, CloudActionType.MustSynch,

                                                     localFile, objectInfo, state, accountInfo.BlockSize,

                                                     accountInfo.BlockHash);

                    }

                }

                else

                {

                    //If there is no match we add them to the localFiles list

                    //but only if the file is not marked for deletion

                    var targetFile = Path.Combine(accountInfo.AccountPath, relativePath);

                    var fileStatus = StatusKeeper.GetFileStatus(targetFile);

                    if (fileStatus != FileStatus.Deleted)

                    {

                        //Remote files should be downloaded

                        yield return new CloudDownloadAction(accountInfo,objectInfo);

                    }

                }

            }            

        }

*/

                //The file's hashmap will be stored in the same location with the extension .hashmap

                //var hashPath = Path.Combine(FileAgent.CachePath, relativePath + ".hashmap");