Synnefo » Pithos MS Client

			var accountInfo=_accounts.FirstOrDefault(account => account.UserName == accountName);

			_accounts.TryRemove(accountInfo);

			PithosMonitor monitor;

			if (Monitors.TryRemove(accountName, out monitor))

			{

using System.Collections.Concurrent;

using System.Collections.Generic;

using System.Diagnostics.Contracts;

using System.Threading;

using System.Threading.Tasks;

using Pithos.Core.Agents;

    public class Agent<TMessage> : IDisposable

    {

        private readonly ConcurrentQueue<TMessage> _queue;

        private readonly CancellationTokenSource _cancelSource = new CancellationTokenSource();

        public CancellationToken CancellationToken;

        public Agent(Action<Agent<TMessage>> action)

        {

            _queue=new ConcurrentQueue<TMessage>();

            _process = action;

            CancellationToken = _cancelSource.Token;

        }

        /// <summary>

        /// Receives a message asynchronously, optionally with a timeout. Receive throws a TimeoutException if the timeout expires

        /// </summary>

        /// <returns>A Task that will return the message asynchronously</returns>

        {

        }

        public void Stop()

        {

            //Stop the message queue

            //And signal the cancellation

            _cancelSource.Cancel();

        }

        public IEnumerable<TMessage> GetEnumerable()

        {

        }

        /// <summary>

        public Lazy<string> LocalHash { get; protected set; }

        [ContractInvariantMethod]

        public override string ToString()

        {

        }

        protected static ObjectInfo CreateObjectInfoFor(AccountInfo accountInfo, FileSystemInfo fileInfo)

        public override string ToString()

        {

        }

    }

        public override string ToString()

        {

        }

    }

 */

#endregion

using System;

using System.Collections.Generic;

using System.ComponentModel.Composition;

using System.Diagnostics;

using System.Diagnostics.Contracts;

using System.IO;

using System.Net;

using System.Threading;

using System.Threading.Tasks;

using Castle.ActiveRecord;

using Pithos.Interfaces;

using Pithos.Network;

namespace Pithos.Core.Agents

{

    [Export]

    public class NetworkAgent

    {

        private static readonly ILog Log = LogManager.GetLogger("NetworkAgent");

        [System.ComponentModel.Composition.Import]

        public IPithosSettings Settings { get; set; }

                    {

                        //Clear the status of already deleted files to avoid reprocessing

                        if (action.LocalFile != null)

                    }

                    else

                    {

                    var accountName = parts[1];

                    var oldName = accountInfo.UserName;

                    var absoluteUri = accountInfo.StorageUri.AbsoluteUri;

                    var root = absoluteUri.Substring(0, nameIndex);

                    accountInfo = new AccountInfo

        }

    }

using System.IO;

using System.Threading;

using System.Threading.Tasks;

using Castle.ActiveRecord;

using Pithos.Interfaces;

using Pithos.Network;

    using System;

    using System.Collections.Generic;

    using System.Linq;

    /// <summary>

    /// PollAgent periodically polls the server to detect object changes. The agent retrieves a listing of all

        //The Sync Event signals a manual synchronisation

        private readonly AsyncManualResetEvent _syncEvent = new AsyncManualResetEvent();

        /// <summary>

            UpdateStatus(PithosStatus.Syncing);

            StatusNotification.Notify(new PollNotification());

            {

                //If this poll fails, we will retry with the same since value

                var nextSince = since;

                    //This is done to ensure there are no discrepancies due to clock differences

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

                                select ProcessAccountFiles(accountInfo, since);

                    await TaskEx.WhenAll(tasks.ToList());

                var client = new CloudFilesClient(accountInfo);

                //We don't need to check the trash container

                CreateContainerFolders(accountInfo, containers);

                    await NetworkAgent.GetDeleteAwaiter();

                    //Get the poll time now. We may miss some deletions but it's better to keep a file that was deleted

                    //than delete a file that was created while we were executing the poll                    

                    //Get the list of server objects changed since the last check

                    //The name of the container is passed as state in order to create a dictionary of tasks in a subsequent step

                    var listObjects = (from container in containers

                                       select Task<IList<ObjectInfo>>.Factory.StartNew(_ =>

                                             client.ListObjects(accountInfo.UserName, container.Name, since), container.Name)).ToList();

                    var listShared = Task<IList<ObjectInfo>>.Factory.StartNew(_ => 

                        client.ListSharedObjects(since), "shared");

                        var differencer = _differencer.PostSnapshot(accountInfo, cleanRemotes);

                        // @@@ NEED To add previous state here as well, To compare with previous hash

            }

        }

        private List<Uri> _selectiveUris=new List<Uri>();

        /// <summary>

        /// </summary>

        /// <param name="accountInfo"></param>

        /// <param name="cloudFiles"></param>

        {

            if (accountInfo == null)

                throw new ArgumentNullException("accountInfo");

            }

        }

        /// <summary>

        /// Notify the UI to update the visual status

        /// </summary>

        public void AddAccount(AccountInfo accountInfo)

        {

        }

    }

}

        private void StartNetworkAgent()

        {

            NetworkAgent.StatusNotification = StatusNotification;

            NetworkAgent.Start();