Synnefo » Pithos MS Client

                </TabItem>

                <TabItem Header="Permissions">

                    <StackPanel>

                <Run Text="Public URL:" />

                <Run Text="{Binding PublicUrl,FallbackValue='http://someurl'}" />

                        </TextBlock>

using System.Diagnostics;

using System.Diagnostics.Contracts;

using System.Drawing;

using System.Net;

using System.Threading.Tasks;

using System.Windows;

                if (IsPublic)

                    PublicUrl = String.Format("{0}/v1{1}", Shell.Accounts.First(account=>account.UserName==PithosFile.Account).SiteUri,value.PublicUrl);

                {

                }

                NotifyOfPropertyChange(()=>PithosFile);

                IsBusy = false;

    <AssemblyOriginatorKeyFile>pithos.snk</AssemblyOriginatorKeyFile>

  </PropertyGroup>

  <PropertyGroup>

  </PropertyGroup>

  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Premium Debug|x86'">

    <DebugSymbols>true</DebugSymbols>

    <Reference Include="WindowsBase" />

    <Reference Include="PresentationCore" />

    <Reference Include="PresentationFramework" />

      <HintPath>..\packages\Extended.Wpf.Toolkit.1.5.0\lib\net40\WPFToolkit.Extended.dll</HintPath>

    </Reference>

  </ItemGroup>

[assembly: AssemblyCopyright("Copyright © GRNet 2011")]

[assembly: AssemblyTrademark("")]

[assembly: AssemblyCulture("")]

// Setting ComVisible to false makes the types in this assembly not visible 

// to COM components.  If you need to access a type in this assembly from 

// You can specify all the values or you can default the Build and Revision Numbers 

// by using the '*' as shown below:

// [assembly: AssemblyVersion("1.0.*")]

using System;

using Caliburn.Micro;

using System.ServiceModel;

using System.ComponentModel.Composition;

using System.Collections.Concurrent;

using System.Diagnostics;

using System.Diagnostics.Contracts;

using System.IO;

using System.Reflection;

using System.Runtime.InteropServices;

using System.ServiceModel;

using System.Threading.Tasks;

using System.Windows;

using Caliburn.Micro;

using Hardcodet.Wpf.TaskbarNotification;

using Pithos.Client.WPF.Configuration;

using Pithos.Client.WPF.FileProperties;

using Pithos.Client.WPF.SelectiveSynch;

using Pithos.Client.WPF.Services;

using Pithos.Client.WPF.Shell;

using System;

using System.Collections.Generic;

using System.Linq;

using Pithos.Network;

using StatusService = Pithos.Client.WPF.Services.StatusService;

	{

		//The Status Checker provides the current synch state

		//TODO: Could we remove the status checker and use events in its place?

		public PithosSettings Settings { get; private set; }

		///<summary>

		/// Dictionary of account monitors, keyed by account

		///</summary>

		}

		//Logging in the Pithos client is provided by log4net

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

		}

		{

			try

			{

		{

			return Task.Factory.StartNew(() =>

			{                                                

				var accountName = account.AccountName;

				if (_monitors.TryGetValue(accountName, out monitor))

				//PithosMonitor uses MEF so we need to resolve it

				IoC.BuildUp(monitor);

				_monitors[accountName] = monitor;

			get { return _statusIcon; }

			set

			{

				NotifyOfPropertyChange(() => StatusIcon);

			}

		}

		{

			if (String.IsNullOrWhiteSpace(filePath))

				throw new ArgumentNullException("filePath");

				throw new ArgumentException(String.Format("Non existent file {0}",filePath),"filePath");

			Contract.EndContractBlock();

			var pair=(from monitor in  Monitors

							   where filePath.StartsWith(monitor.Value.RootPath, StringComparison.InvariantCultureIgnoreCase)

								   select monitor).FirstOrDefault();

			if (accountMonitor == null)

				return;

			var pair=(from monitor in  Monitors

							   where filePath.StartsWith(monitor.Value.RootPath, StringComparison.InvariantCultureIgnoreCase)

								   select monitor).FirstOrDefault();

			var info = accountMonitor.GetContainerInfo(filePath);

		#endregion

			{

				new StatusInfo(PithosStatus.InSynch, "All files up to date", "TrayInSynch"),

				new StatusInfo(PithosStatus.Syncing, "Syncing Files", "TraySynching"),

		{

			var pithosStatus = _statusChecker.GetPithosStatus();

			{

				StatusIcon = String.Format(@"../Images/{0}.ico", info.IconName);

				Assembly assembly = Assembly.GetExecutingAssembly();                               

				var credentials = await PithosAccount.RetrieveCredentials(Settings.PithosLoginUrl);

				account.ApiKey = credentials.Password;

				monitor.ApiKey = credentials.Password;

				Settings.Save();

				string message = String.Format("API Key retrieval for {0} failed", monitor.UserName);

				Log.Error(message, exc.InnerException);

				_events.Publish(new Notification { Title = "Authorization failed", Message = message, Level = TraceLevel.Error });

			}

			catch (Exception exc)

			{

				string message = String.Format("API Key retrieval for {0} failed", monitor.UserName);

				Log.Error(message, exc);

				_events.Publish(new Notification { Title = "Authorization failed", Message = message, Level = TraceLevel.Error });

			}

		}

		public void NotifyChange(string status, TraceLevel level=TraceLevel.Info)

		{

			_events.Publish(new Notification { Title = "Pithos", Message = status, Level = level });

		}

		public void NotifyChangedFile(string filePath)

		{

			var entry = new FileEntry {FullPath=filePath};

			FileEntry popped;

			while (files.Count > 5)

				files.TryTake(out popped);

		{

			if (!Settings.ShowDesktopNotifications)

				return;

			switch (notification.Level)

			{

				case TraceLevel.Error:

			if (Settings.ShowDesktopNotifications)

			{

				tv.TaskbarView.ShowBalloonTip(notification.Title, notification.Message, icon);

			}

		}

			Contract.EndContractBlock();

			var fileName = message.FileName;

			if (File.Exists(fileName))

			else if (Directory.Exists(fileName))

		}

	}

}

    {

        public AccountInfo AccountInfo { get; set; }

        public CloudActionType Action { get; set; }

        public ObjectInfo CloudFile { get; set; }

        public FileState FileState { get; set; }

        public string Container { get; set; }

            AccountInfo = accountInfo;

        }

            : this(accountInfo,action)

        {

            LocalFile = localFile;

            FileState = state;

            if (LocalFile != null)

            {

                LocalHash = new Lazy<string>(() => LocalFile.CalculateHash(blockSize,algorithm),

                                             LazyThreadSafetyMode.ExecutionAndPublication);

            }

    }

    public class CloudDeleteAction:CloudAction

    {

            : this(accountInfo,new ObjectInfo(accountInfo.AccountPath,accountInfo.UserName,fileInfo),fileState)

        {

        }

    public class CloudUploadAction:CloudAction

    {

            : base(accountInfo, CloudActionType.UploadUnconditional, fileInfo, 

            new ObjectInfo(accountInfo.AccountPath, accountInfo.UserName,fileInfo), state, blockSize, algorithm)

        {

    {

        public ObjectInfo OldCloudFile { get; set; }

            :base(accountInfo,action)

        {

            LocalFile = newFile;

                throw new ArgumentNullException("state");

            Contract.EndContractBlock();

            var networkState = NetworkGate.GetNetworkState(state.Path);

            //Skip if the file is already being downloaded or uploaded and 

        private bool Ignore(string filePath)

        {

            if (filePath.StartsWith(CachePath))

                return true;

            if (_ignoreFiles.ContainsKey(filePath.ToLower()))

            var filePath = e.FullPath;

            if (Ignore(filePath)) 

                return;

            _agent.Post(new WorkflowState{AccountInfo=AccountInfo, Path = filePath, FileName = e.Name, TriggeringChange = e.ChangeType });

        }

            return false;

        }

        {

            if (String.IsNullOrWhiteSpace(relativePath))

                throw new ArgumentNullException("relativePath");

            Contract.EndContractBlock();            

            var absolutePath = Path.Combine(RootPath, relativePath);

        }

        public void Delete(string relativePath)

        {

            if (File.Exists(absolutePath))

            }

            StatusKeeper.ClearFileStatus(absolutePath);

        }

    }

            }

        }

        {

            if (info==null)

                throw new ArgumentNullException("info");

                throw new ArgumentNullException("algorithm");

            Contract.EndContractBlock();

                return Signature.CalculateMD5(info.FullName);

            else

                return Signature.CalculateTreeHash(info.FullName, blockSize, algorithm).TopHash.ToHashString();

        }

    }

}

using System;

using System.Collections.Generic;

using System.ComponentModel.Composition;

using System.Diagnostics;

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

        public void Start()

        {

                            RenameCloudFile(accountInfo, moveAction);

                            break;

                        case CloudActionType.MustSynch:

                            {

                                await DownloadCloudFile(accountInfo, cloudFile, downloadPath);

                            }

            Contract.EndContractBlock();

            //If the action targets a local file, add a treehash calculation

            {

                var accountInfo = cloudAction.AccountInfo;

                {

                }

            }

            _agent.Post(cloudAction);

        }

                    var tasks = from accountInfo in _accounts

                                select ProcessAccountFiles(accountInfo, since);

                    ProcessRemoteFiles(nextSince);

                }

            }

        }

        {

            var containerPaths = from container in containers

                                 let containerPath = Path.Combine(accountInfo.AccountPath, container.Name)

                if (fileAgent.Exists(relativePath))

                {

                    var localFile = fileAgent.GetFileInfo(relativePath);

                    var state = FileState.FindByFilePath(localFile.FullName);

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

                    var cloudFile = action.CloudFile;

                    var account = cloudFile.Account ?? accountInfo.UserName;

                    //Even if GetObjectInfo times out, we can proceed with the upload            

                    var info = client.GetObjectInfo(account, cloudFile.Container, cloudFile.Name);

                    {

                    }

                    //If everything succeeds, change the file and overlay status to normal

                    StatusKeeper.SetFileState(fullFileName, FileStatus.Unchanged, FileOverlayStatus.Normal);

                }

                    }

                    string path = state.Path.ToLower();

                    //Bypass deleted files, unless the status is Deleted

                    {

                        state.Skip = true;

                        this.StatusKeeper.ClearFileStatus(path);

                    }

                    var fileState = FileState.FindByFilePath(path);

                    switch (state.Status)

                            NetworkAgent.Post(new CloudDeleteAction(accountInfo, info, fileState));

                            break;

                        case FileStatus.Renamed:

                            NetworkAgent.Post(new CloudMoveAction(accountInfo, CloudActionType.RenameCloud,

                            break;

                    }

                var pendingStates = new List<WorkflowState>();

                foreach (var state in pendingEntries)

                {

                        pendingStates.Add(new WorkflowState(account, state));

                }

                if (Log.IsDebugEnabled)

                foreach (var entry in pendingStates)

                {

                }

            }

        }

                Log.DebugFormat("Posted {0} {1} {2}", workflowState.Path, workflowState.Status, workflowState.TriggeringChange);

            //Remove invalid state            

            Debug.Assert(workflowState.Path.StartsWith(workflowState.AccountInfo.AccountPath, StringComparison.InvariantCultureIgnoreCase), "File from wrong account posted");

{

    public static class FileInfoExtensions

    {

        {

            if (String.IsNullOrWhiteSpace(path))

                throw new ArgumentNullException("path");            

            return relativePath;

        }

        {

            if (String.IsNullOrWhiteSpace(path))

                throw new ArgumentNullException("path");

        public ObjectInfo()

        {}

        {

            if (String.IsNullOrWhiteSpace(accountPath))

                throw new ArgumentNullException("accountPath");

        private string GetAccountUrl(string account)

        {

        }

        public IList<ShareAccountInfo> ListSharingAccounts(DateTime? since=null)

        {

            {

                if (Log.IsDebugEnabled) Log.DebugFormat("START");

        public IList<ObjectInfo> ListSharedObjects(DateTime? since = null)

        {

            {

                if (Log.IsDebugEnabled) Log.DebugFormat("START");

                    var containers = ListContainers(account.name);

                    foreach (var container in containers)

                    {

                        objects.AddRange(containerObjects);

                    }

                }

                throw new ArgumentNullException("target");

            Contract.EndContractBlock();

            {

                if (Log.IsDebugEnabled) Log.DebugFormat("START");

                        client.Headers.Add(headerTag, tag.Value);

                    }

                    client.AssertStatusOK("SetTags failed");

                throw new ArgumentNullException("shareTo");

            Contract.EndContractBlock();

            {

                if (Log.IsDebugEnabled) Log.DebugFormat("START");

                throw new ArgumentNullException("accountInfo");

            Contract.EndContractBlock();

            {

                if (Log.IsDebugEnabled) Log.DebugFormat("START");

                throw new ArgumentNullException("objectInfo");

            Contract.EndContractBlock();

            {

                if (Log.IsDebugEnabled) Log.DebugFormat("START");

                    var uriBuilder = client.GetAddressBuilder(objectInfo.Container, objectInfo.Name);

                    var uri = uriBuilder.Uri;

                    client.AssertStatusOK("UpdateMetadata failed");

                throw new ArgumentNullException("containerInfo");

            Contract.EndContractBlock();

            {

                if (Log.IsDebugEnabled) Log.DebugFormat("START");

                    var uriBuilder = client.GetAddressBuilder(containerInfo.Name,"");

                    var uri = uriBuilder.Uri;

                    client.AssertStatusOK("UpdateMetadata failed");

                throw new ArgumentNullException("container");

            Contract.EndContractBlock();

            {

                if (Log.IsDebugEnabled) Log.DebugFormat("START");

                throw new ArgumentNullException("folder");

            Contract.EndContractBlock();

            {

                if (Log.IsDebugEnabled) Log.DebugFormat("START");

                throw new ArgumentNullException("container", "The container property can't be empty");

            Contract.EndContractBlock();

            {

                if (Log.IsDebugEnabled) Log.DebugFormat("START");

                throw new ArgumentNullException("objectName", "The objectName property can't be empty");

            Contract.EndContractBlock();

            {                

                using (var client = new RestClient(_baseClient))

                    }

                    catch (RetryException)

                    {

                        return ObjectInfo.Empty;

                    }

                    catch (WebException e)

                            return hashes;

                        }                        

                }

                //Any other status code is unexpected but there was no exception. We can probably continue processing

                return empty;

            });

        }

        {

            if (String.IsNullOrWhiteSpace(container))

                throw new ArgumentNullException("container");

                throw new InvalidOperationException("Invalid Storage Url");                        

            Contract.EndContractBlock();

                }

        }

        /// <param name="fileName"></param>

        /// <param name="hash">Optional hash value for the file. If no hash is provided, the method calculates a new hash</param>

        /// <remarks>>This method should have no timeout or a very long one</remarks>

        {

            if (String.IsNullOrWhiteSpace(container))

                throw new ArgumentNullException("container", "The container property can't be empty");

                throw new ArgumentNullException("objectName", "The objectName property can't be empty");

            if (String.IsNullOrWhiteSpace(fileName))

                throw new ArgumentNullException("fileName", "The fileName property can't be empty");

            Contract.EndContractBlock();

            try

            {

                {

            }

            catch (Exception exc)

            {

        #region Object operations        

        Task GetObject(string account, string container, string objectName, string fileName);

        void DeleteObject(string account, string container, string objectName);

        //void DeleteObject(string container, string objectName, string account = null);

        void MoveObject(string account, string sourceContainer, string oldObjectName, string targetContainer, string newObjectName);

            return default(Task);

        }

        {

            Contract.Requires(!String.IsNullOrWhiteSpace(Token));

            Contract.Requires(!String.IsNullOrWhiteSpace(container));

            Contract.Requires(!String.IsNullOrWhiteSpace(fileName));                        

            Contract.Requires(!String.IsNullOrWhiteSpace(objectName));

            return default(Task);

        }

        "Entry"

        {

        "MsmKey" = "8:_00C78A0AE638245667A5681AAAA0F51F"

        "OwnerKey" = "8:_EBAF62F0335F4918AB23EDA708507D1F"

        "MsmSig" = "8:_UNDEFINED"

        }

        "Entry"

        {

        "MsmKey" = "8:_07169606B53C447F3C4DEF318E8BB147"

        "MsmSig" = "8:_UNDEFINED"

        }

        "Entry"

        }

        "Entry"

        {

        "MsmKey" = "8:_13807DF64A18092E2104382D6350B99E"

        "OwnerKey" = "8:_1BD6A9CD577C40098C968C8B464A03BC"

        "MsmSig" = "8:_UNDEFINED"

        "Entry"

        {

        "MsmKey" = "8:_13807DF64A18092E2104382D6350B99E"

        "OwnerKey" = "8:_3455E6F41DFDCA75B1C8BAD894A467F2"

        "MsmSig" = "8:_UNDEFINED"

        }

        }

        "Entry"

        {

        "MsmKey" = "8:_1BD6A9CD577C40098C968C8B464A03BC"

        "OwnerKey" = "8:_UNDEFINED"

        "MsmSig" = "8:_UNDEFINED"

        "Entry"

        {

        "MsmKey" = "8:_2486B3A261E9B1189CF1D6B7923DEEE4"

        "OwnerKey" = "8:_15C6D19249891DD0DF6332A0CC3AAB34"

        "MsmSig" = "8:_UNDEFINED"

        }

        "Entry"

        {

        "MsmKey" = "8:_3455E6F41DFDCA75B1C8BAD894A467F2"

        "OwnerKey" = "8:_EBAF62F0335F4918AB23EDA708507D1F"

        "MsmSig" = "8:_UNDEFINED"

        }

        "Entry"

        {

        "MsmKey" = "8:_4DEB12AE1A97F1592C5B75ADEBF86C3D"

        "OwnerKey" = "8:_EBAF62F0335F4918AB23EDA708507D1F"

        "MsmSig" = "8:_UNDEFINED"

        }

        }

        "Entry"

        {

        "MsmKey" = "8:_5A954DFDECEA1772693C525449B45377"

        "OwnerKey" = "8:_94AF0407772DC0469EA5A27F079132FE"

        "MsmSig" = "8:_UNDEFINED"

        "Entry"

        {

        "MsmKey" = "8:_5A954DFDECEA1772693C525449B45377"

        "OwnerKey" = "8:_EBAF62F0335F4918AB23EDA708507D1F"

        "MsmSig" = "8:_UNDEFINED"

        }

        "Entry"

        {

        "MsmKey" = "8:_5BDDF78B8F57F5F0C86B681FC536679D"

        "OwnerKey" = "8:_3455E6F41DFDCA75B1C8BAD894A467F2"

        "MsmSig" = "8:_UNDEFINED"

        }

        "Entry"

        {

        "MsmKey" = "8:_5CB7E7BC9A3FBCBBAAA5B13892A9804A"

        "OwnerKey" = "8:_EBAF62F0335F4918AB23EDA708507D1F"

        "MsmSig" = "8:_UNDEFINED"

        }

        "Entry"

        {

        "MsmKey" = "8:_86C6A4ACD935E66BC53753149FB5DB8E"

        "OwnerKey" = "8:_15C6D19249891DD0DF6332A0CC3AAB34"

        "MsmSig" = "8:_UNDEFINED"

        }

        }

        "Entry"

        {

        "MsmKey" = "8:_9C9414F9AC6F40DD9B23916692C951BE"

        "OwnerKey" = "8:_UNDEFINED"

        "MsmSig" = "8:_UNDEFINED"

        "Entry"

        {

        "MsmKey" = "8:_B0464BCF85DA5A9724AC7A145E4742A1"

        "OwnerKey" = "8:_EBAF62F0335F4918AB23EDA708507D1F"

        "MsmSig" = "8:_UNDEFINED"

        }

        "Entry"

        {

        "MsmKey" = "8:_C19B1A60C99103E4AB0CB34FBD46A86E"

        "OwnerKey" = "8:_EBAF62F0335F4918AB23EDA708507D1F"

        "MsmSig" = "8:_UNDEFINED"

        }

        }

        "Entry"

        {

        "MsmSig" = "8:_UNDEFINED"

        }

        "Entry"

        "Entry"

        {

        "MsmKey" = "8:_D90F384DDD0DCD7EF3877F70303E7A5E"

        "OwnerKey" = "8:_3455E6F41DFDCA75B1C8BAD894A467F2"

        "MsmSig" = "8:_UNDEFINED"

        }

        "Entry"

        {

        "MsmKey" = "8:_DB755C1EAC71B2C6FAB0C47B84E8DC98"

        "OwnerKey" = "8:_15C6D19249891DD0DF6332A0CC3AAB34"

        "MsmSig" = "8:_UNDEFINED"

        }