Synnefo » Pithos MS Client

		    var progress = notification as ProgressNotification;

		    if (progress != null)

		    {

		        StatusMessage = String.Format("Pithos {0}\r\n{1} {2} of {3} - {4}",

		                                      _fileVersion.Value.FileVersion, 

                                              progress.Action,

		                                      progress.Block/(double)progress.TotalBlocks,

		                                      progress.FileSize.ToByteSize(),

		                                      progress.FileName);

		        return;

		    }

	<configSections>

		<sectionGroup name="userSettings" type="System.Configuration.UserSettingsGroup, System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089">

			<section name="Pithos.Client.WPF.Properties.Settings" type="System.Configuration.ClientSettingsSection, System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" allowExeDefinition="MachineToLocalUser" requirePermission="false" />

		</sectionGroup>

		<sectionGroup name="applicationSettings" type="System.Configuration.ApplicationSettingsGroup, System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089">

			<section name="Pithos.Client.WPF.Properties.Settings" type="System.Configuration.ClientSettingsSection, System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" requirePermission="false" />

		</sectionGroup>

		<section name="log4net" type="log4net.Config.Log4NetConfigurationSectionHandler, log4net" />

	</configSections>

	<runtime>

		<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">

			<dependentAssembly>

				<assemblyIdentity name="Caliburn.Micro" publicKeyToken="8e5891231f2ed21f" culture="neutral" />

				<bindingRedirect oldVersion="0.0.0.0-1.2.0.0" newVersion="1.2.0.0" />

			</dependentAssembly>

			<dependentAssembly>

				<assemblyIdentity name="NHibernate" publicKeyToken="aa95f207798dfdb4" culture="neutral" />

				<bindingRedirect oldVersion="0.0.0.0-3.1.0.4000" newVersion="3.1.0.4000" />

			</dependentAssembly>

			<dependentAssembly>

				<assemblyIdentity name="NHibernate.ByteCode.Castle" publicKeyToken="aa95f207798dfdb4" culture="neutral" />

				<bindingRedirect oldVersion="0.0.0.0-3.1.0.4000" newVersion="3.1.0.4000" />

			</dependentAssembly>

		</assemblyBinding>

	</runtime>

	<userSettings>

		<Pithos.Client.WPF.Properties.Settings>

			<setting name="PithosPath" serializeAs="String">

				<value>e:\Pithos</value>

			</setting>

			<setting name="IconPath" serializeAs="String">

				<value>C:\Program Files\Common Files\TortoiseOverlays\icons\XPStyle</value>

			</setting>

			<setting name="ProxyServer" serializeAs="String">

				<value />

			</setting>

			<setting name="ProxyPort" serializeAs="String">

				<value>8080</value>

			</setting>

			<setting name="ProxyUsername" serializeAs="String">

				<value />

			</setting>

			<setting name="ProxyPassword" serializeAs="String">

				<value />

			</setting>

			<setting name="ProxyAuthentication" serializeAs="String">

				<value>True</value>

			</setting>

			<setting name="ExtensionsActivated" serializeAs="String">

				<value>True</value>

			</setting>

			<setting name="UserName" serializeAs="String">

				<value>pkanavos</value>

			</setting>

			<setting name="ApiKey" serializeAs="String">

				<value>9d3cb7b231e96f72ebe96af1c6cd5112</value>

			</setting>

			<setting name="ShowDesktopNotifications" serializeAs="String">

				<value>True</value>

			</setting>

			<setting name="StartOnSystemStartup" serializeAs="String">

				<value>True</value>

			</setting>

			<setting name="UseNoProxy" serializeAs="String">

				<value>False</value>

			</setting>

			<setting name="UseDefaultProxy" serializeAs="String">

				<value>True</value>

			</setting>

			<setting name="UseManualProxy" serializeAs="String">

				<value>False</value>

			</setting>

			<setting name="MustUpgrade" serializeAs="String">

				<value>True</value>

			</setting>

			<setting name="PollingInterval" serializeAs="String">

				<value>10</value>

			</setting>

			<setting name="ProxyDomain" serializeAs="String">

				<value />

			</setting>

			<setting name="HashingParallelism" serializeAs="String">

				<value>1</value>

			</setting>

			<setting name="StartupDelay" serializeAs="String">

				<value>00:01:00</value>

			</setting>

		</Pithos.Client.WPF.Properties.Settings>

	</userSettings>

	<connectionStrings>

		<add name="Sqlite_InMemory" providerName="System.Data.SQLite" connectionString="Data Source=:memory:;Version=3;New=True" />

	</connectionStrings>

	<system.data>

		<DbProviderFactories>

			<remove invariant="System.Data.SQLite" />

			<add name="SQLite Data Provider" invariant="System.Data.SQLite" description=".Net Framework Data Provider for SQLite" type="System.Data.SQLite.SQLiteFactory, System.Data.SQLite" />

		</DbProviderFactories>

	</system.data>

	<startup useLegacyV2RuntimeActivationPolicy="true">

		<supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.0,Profile=Client" />

	</startup>

	<applicationSettings>

		<Pithos.Client.WPF.Properties.Settings>

			<setting name="CloudfilesAuthenticationUrl" serializeAs="String">

				<value>https://auth.api.rackspacecloud.com</value>

			</setting>

			<setting name="PithosLoginUrl" serializeAs="String">

				<value>https://pithos.dev.grnet.gr/login</value>

			</setting>

			<setting name="FeedbackUri" serializeAs="String">

				<value>https://pithos.dev.grnet.gr/im/feedback</value>

			</setting>

			<setting name="ProductionServer" serializeAs="String">

				<value>https://plus.pithos.grnet.gr</value>

			</setting>

			<setting name="DevelopmentServer" serializeAs="String">

				<value>https://pithos.dev.grnet.gr</value>

			</setting>

		</Pithos.Client.WPF.Properties.Settings>

	</applicationSettings>

	<log4net>

		<appender name="TraceAppender" type="log4net.Appender.TraceAppender" >

			<layout type="log4net.Layout.PatternLayout">

				<conversionPattern value="%logger (%property{CloudFile}) [%level]- %message%newline" />

			</layout>

			<filter type="log4net.Filter.LoggerMatchFilter">

				<loggerToMatch value="NHibernate" />

				<acceptOnMatch value="false" />

			</filter>

			<filter type="log4net.Filter.LoggerMatchFilter">

				<loggerToMatch value="Caliburn" />

				<acceptOnMatch value="false" />

			</filter>

		</appender>

		<appender name="DumpFileAppender" type="log4net.Appender.RollingFileAppender">

			<file value="log.txt" />

			<appendToFile value="false" />

			<rollingStyle value="Size" />

			<maxSizeRollBackups value="10" />

			<maximumFileSize value="100KB" />

			<staticLogFileName value="true" />

			<layout type="log4net.Layout.XMLLayout"/>

		</appender>

		<appender name="OutputDebugStringAppender" type="log4net.Appender.OutputDebugStringAppender" >

			<layout type="log4net.Layout.PatternLayout">

				<conversionPattern value="%logger (%property{Operation}) [%level]- %message%newline" />

			</layout>

		</appender>

		<appender name="LossyFileAppender" type="log4net.Appender.BufferingForwardingAppender">

			<filter type="log4net.Filter.LevelRangeFilter">

				<levelMin value="DEBUG" />

				<levelMax value="FATAL" />

			</filter>

			<bufferSize value="30" />

			<lossy value="true"/>

			<evaluator type="log4net.Core.LevelEvaluator">

				<threshold value="ERROR" />

			</evaluator>

			<appender-ref ref="DumpFileAppender" />

		</appender>

		<logger name="NHibernate" additivity="false">

			<level value="WARN"/>

			<appender-ref ref="TraceAppender"/>

		</logger>

		<logger name="Caliburn" additivity="false">

			<level value="WARN"/>

			<appender-ref ref="TraceAppender"/>

		</logger>

		<root>

			<level value="DEBUG" />

			<appender-ref ref="LossyFileAppender" />

			<appender-ref ref="TraceAppender" />

			<appender-ref ref="OutputDebugStringAppender" />

		</root>

	</log4net>

            using (log4net.ThreadContext.Stacks["Operation"].Push("ProcessDelete"))

            using (ThreadContext.Stacks["Operation"].Push("DeleteCloudFile"))

            using (log4net.ThreadContext.Stacks["Operation"].Push(action.ToString()))

                    //UpdateStatus(PithosStatus.Syncing);

                    Log.InfoFormat("End Processing {0}:{1}->{2}", action.Action, action.LocalFile,

            using (ThreadContext.Stacks["Operation"].Push("RenameLocalFile"))

            {

                //We assume that the local file already exists, otherwise the poll agent

                //would have issued a download request

                var currentInfo = action.CloudFile;

                var previousInfo = action.CloudFile.Previous;

                var fileAgent = FileAgent.GetFileAgent(accountInfo);

                var previousRelativepath = previousInfo.RelativeUrlToFilePath(accountInfo.UserName);

                var previousFile = fileAgent.GetFileSystemInfo(previousRelativepath);

                //In every case we need to move the local file first

                MoveLocalFile(accountInfo, previousFile, fileAgent, currentInfo);

            }

            using (ThreadContext.Stacks["Operation"].Push("SyncFiles"))

            {

                var localFile = action.LocalFile;

                var cloudFile = action.CloudFile;

                var downloadPath = action.LocalFile.GetProperCapitalization();

                var cloudHash = cloudFile.Hash.ToLower();

                var previousCloudHash = cloudFile.PreviousHash.ToLower();

                var localHash = action.LocalHash.Value.ToLower();

                var topHash = action.TopHash.Value.ToLower();

                //At this point we know that an object has changed on the server and that a local

                //file already exists. We need to decide whether the file has only changed on 

                //the server or there is a conflicting change on the client.

                //

                //Not enough to compare only the local hashes (MD5), also have to compare the tophashes            

                //If any of the hashes match, we are done

                if ((cloudHash == localHash || cloudHash == topHash))

                {

                    Log.InfoFormat("Skipping {0}, hashes match", downloadPath);

                    return;

                }

                //The hashes DON'T match. We need to sync

                // If the previous tophash matches the local tophash, the file was only changed on the server. 

                if (localHash == previousCloudHash)

                {

                    await DownloadCloudFile(accountInfo, cloudFile, downloadPath);

                }

                else

                {

                    //If the previous and local hash don't match, there was a local conflict

                    //that was not uploaded to the server. We have a conflict

                    ReportConflict(downloadPath);

                }

            using (ThreadContext.Stacks["Operation"].Push("RenameCloudFile"))

            {

                var newFilePath = action.LocalFile.FullName;

                //How do we handle concurrent renames and deletes/uploads/downloads?

                //* A conflicting upload means that a file was renamed before it had a chance to finish uploading

                //  This should never happen as the network agent executes only one action at a time

                //* A conflicting download means that the file was modified on the cloud. While we can go on and complete

                //  the rename, there may be a problem if the file is downloaded in blocks, as subsequent block requests for the 

                //  same name will fail.

                //  This should never happen as the network agent executes only one action at a time.

                //* A conflicting delete can happen if the rename was followed by a delete action that didn't have the chance

                //  to remove the rename from the queue.

                //  We can probably ignore this case. It will result in an error which should be ignored            

                //The local file is already renamed

                StatusKeeper.SetFileOverlayStatus(newFilePath, FileOverlayStatus.Modified);

                var account = action.CloudFile.Account ?? accountInfo.UserName;

                var container = action.CloudFile.Container;

                var client = new CloudFilesClient(accountInfo);

                //TODO: What code is returned when the source file doesn't exist?

                client.MoveObject(account, container, action.OldCloudFile.Name, container, action.CloudFile.Name);

                StatusKeeper.SetFileStatus(newFilePath, FileStatus.Unchanged);

                StatusKeeper.SetFileOverlayStatus(newFilePath, FileOverlayStatus.Normal);

                NativeMethods.RaiseChangeNotification(newFilePath);

            }

            using (ThreadContext.Stacks["Operation"].Push("DownloadCloudFile"))

            {

                var localPath = Interfaces.FileInfoExtensions.GetProperFilePathCapitalization(filePath);

                var relativeUrl = new Uri(cloudFile.Name, UriKind.Relative);

                var url = relativeUrl.ToString();

                if (cloudFile.Name.EndsWith(".ignore", StringComparison.InvariantCultureIgnoreCase))

                //Are we already downloading or uploading the file? 

                using (var gate = NetworkGate.Acquire(localPath, NetworkOperation.Downloading))

                    if (gate.Failed)

                        return;

                    var client = new CloudFilesClient(accountInfo);

                    var account = cloudFile.Account;

                    var container = cloudFile.Container;

                    if (cloudFile.Content_Type == @"application/directory")

                        if (!Directory.Exists(localPath))

                            Directory.CreateDirectory(localPath);

                    }

                    else

                    {

                        //Retrieve the hashmap from the server

                        var serverHash = await client.GetHashMap(account, container, url);

                        //If it's a small file

                        if (serverHash.Hashes.Count == 1)

                            //Download it in one go

                            await

                                DownloadEntireFileAsync(accountInfo, client, cloudFile, relativeUrl, localPath,

                                                        serverHash);

                            //Otherwise download it block by block

                        else

                            await DownloadWithBlocks(accountInfo, client, cloudFile, relativeUrl, localPath, serverHash);

                        if (cloudFile.AllowedTo == "read")

                        {

                            var attributes = File.GetAttributes(localPath);

                            File.SetAttributes(localPath, attributes | FileAttributes.ReadOnly);

                        }

                    //Now we can store the object's metadata without worrying about ghost status entries

                    StatusKeeper.StoreInfo(localPath, cloudFile);

                }

            ReportDownloadProgress(Path.GetFileName(localPath),0,upHashes.Length,cloudFile.Bytes);

                ReportDownloadProgress(Path.GetFileName(localPath), i, upHashes.Length, cloudFile.Bytes);

            using(ThreadContext.Stacks["Operation"].Push("UploadCloudFile"))

            {

                try

                    var accountInfo = action.AccountInfo;

                    var fileInfo = action.LocalFile;

                    if (fileInfo.Extension.Equals("ignore", StringComparison.InvariantCultureIgnoreCase))

                    var relativePath = fileInfo.AsRelativeTo(accountInfo.AccountPath);

                    if (relativePath.StartsWith(FolderConstants.OthersFolder))

                        var parts = relativePath.Split('\\');

                        var accountName = parts[1];

                        var oldName = accountInfo.UserName;

                        var absoluteUri = accountInfo.StorageUri.AbsoluteUri;

                        var nameIndex = absoluteUri.IndexOf(oldName, StringComparison.Ordinal);

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

                        accountInfo = new AccountInfo

                                          {

                                              UserName = accountName,

                                              AccountPath = Path.Combine(accountInfo.AccountPath, parts[0], parts[1]),

                                              StorageUri = new Uri(root + accountName),

                                              BlockHash = accountInfo.BlockHash,

                                              BlockSize = accountInfo.BlockSize,

                                              Token = accountInfo.Token

                                          };

                    var fullFileName = fileInfo.GetProperCapitalization();

                    using (var gate = NetworkGate.Acquire(fullFileName, NetworkOperation.Uploading))

                        //Abort if the file is already being uploaded or downloaded

                        if (gate.Failed)

                            return;

                        var cloudFile = action.CloudFile;

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

                        var client = new CloudFilesClient(accountInfo);

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

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

                        //If this is a read-only file, do not upload changes

                        if (info.AllowedTo == "read")

                        //TODO: Check how a directory hash is calculated -> All dirs seem to have the same hash

                        if (fileInfo is DirectoryInfo)

                        {

                            //If the directory doesn't exist the Hash property will be empty

                            if (String.IsNullOrWhiteSpace(info.Hash))

                                //Go on and create the directory

                                await

                                    client.PutObject(account, cloudFile.Container, cloudFile.Name, fullFileName,

                                                     String.Empty, "application/directory");

                        else

                        {

                            var cloudHash = info.Hash.ToLower();

                            var hash = action.LocalHash.Value;

                            var topHash = action.TopHash.Value;

                            //If the file hashes match, abort the upload

                            if (hash == cloudHash || topHash == cloudHash)

                            {

                                //but store any metadata changes 

                                StatusKeeper.StoreInfo(fullFileName, info);

                                Log.InfoFormat("Skip upload of {0}, hashes match", fullFileName);

                                return;

                            }

                            //Mark the file as modified while we upload it

                            StatusKeeper.SetFileOverlayStatus(fullFileName, FileOverlayStatus.Modified);

                            //And then upload it

                            //Upload even small files using the Hashmap. The server may already contain

                            //the relevant block

                            //First, calculate the tree hash

                            var treeHash = await Signature.CalculateTreeHashAsync(fullFileName, accountInfo.BlockSize,

                                                                                  accountInfo.BlockHash, 2);

                            await

                                UploadWithHashMap(accountInfo, cloudFile, fileInfo as FileInfo, cloudFile.Name, treeHash);

                        }

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

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

                    //Notify the Shell to update the overlays

                    NativeMethods.RaiseChangeNotification(fullFileName);

                    StatusNotification.NotifyChangedFile(fullFileName);

                }

                catch (AggregateException ex)

                {

                    var exc = ex.InnerException as WebException;

                    if (exc == null)

                        throw ex.InnerException;

                    if (HandleUploadWebException(action, exc))

                        return;

                    throw;

                }

                catch (WebException ex)

                {

                    if (HandleUploadWebException(action, ex))

                        return;

                    throw;

                }

                catch (Exception ex)

                {

                    Log.Error("Unexpected error while uploading file", ex);

                    throw;

            var client = new CloudFilesClient(accountInfo);            

            int block = 0;

            ReportUploadProgress(fileInfo.Name,block++, missingHashes.Count, fileInfo.Length);

                        Log.Error(String.Format("Uploading block {0} of {1}", blockIndex, fullFileName), exc);

                    ReportUploadProgress(fileInfo.Name,block++, missingHashes.Count, fileInfo.Length);

            ReportUploadProgress(fileInfo.Name, missingHashes.Count, missingHashes.Count, fileInfo.Length);

        private void ReportUploadProgress(string fileName,int block, int totalBlocks, long fileSize)

        {

            StatusNotification.Notify(new ProgressNotification(fileName,"Uploading",block,totalBlocks,fileSize) );            

        }

        private void ReportDownloadProgress(string fileName,int block, int totalBlocks, long fileSize)

        {

            StatusNotification.Notify(new ProgressNotification(fileName,"Downloading",block,totalBlocks,fileSize) );            

        }

                    Log.DebugFormat("Handle deleted [{0}]",objectInfo.Uri);

                    Log.DebugFormat("Will delete [{0}] for [{1}]", item.FullName,objectInfo.Uri);

                        var directory = item as DirectoryInfo;

                        if (directory!=null)

                            directory.Delete(true);

                        else

                            item.Delete();

                        Log.DebugFormat("Deleted [{0}] for [{1}]", item.FullName, objectInfo.Uri);

                Log.InfoFormat("[{0}] files were deleted",deletedFiles.Count);

                    //TODO: Need a way to attach the hashes to the filestate so we don't

                    //recalculate them each time a call to calculate has is made

                    //We can either store them to the filestate or add them to a 

                    //dictionary

        [System.ComponentModel.Composition.Import]

        public IPithosSettings Settings { get; set; }

            using (log4net.ThreadContext.Stacks["Operation"].Push("RestartInterrupted"))

                                           state.FilePath.StartsWith(account.AccountPath)                                            

    public class ProgressNotification:Notification

    {

        public string FileName { get; set; }

        public int Block { get; set; }

        public int TotalBlocks { get; set; }

        public long FileSize { get; set; }

        public string Action { get; set; }

        public ProgressNotification(string fileName, string action,int block, int totalBlocks, long fileSize)

        {

            FileName = fileName;

            Block = block;

            TotalBlocks = totalBlocks;

            FileSize = fileSize;

            Action = action;

        }

    }

            using (ThreadContext.Stacks["Operation"].Push("Indexing local files"))

                return StorageUri==null 

                    ? new Uri(relativeUrl,UriKind.Relative) 

                    : new Uri(StorageUri, relativeUrl);

using System.Reflection;

        private static readonly log4net.ILog Log = log4net.LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);

            var path = stream.Name;

            var size = stream.Length;

            Log.DebugFormat("Hashing [{0}] size [{1}]",path,size);

/*

*/

            using (var hasher = HashAlgorithm.Create(algorithm))

                while ((read = await stream.ReadAsync(buffer, 0, blockSize)) > 0)

                {

                    //                var block = new byte[read];

                    //This code was added for compatibility with the way Pithos calculates the last hash

                    //We calculate the hash only up to the last non-null byte

                    var lastByteIndex = Array.FindLastIndex(buffer, read - 1, aByte => aByte != 0);

                    var hash = hasher.ComputeHash(buffer, 0, lastByteIndex + 1);

                    Log.DebugFormat("Hashed [{0}] [{1}/{2}] [{3:p}]", path, index,size,(double)index/size);

                    hashes[index] = hash;

                    index += read;

                }

                /*

                                Buffer.BlockCopy(buffer,0,block,0,read);

                                await hashBlock.SendAsync(Tuple.Create(index, block));

                */

            }

/*

*/

        {            

            Log.InfoFormat("[{0}] {1}", request.Method, request.RequestUri); 

                Log.WarnFormat("[{0}] {1} {2}", request.Method, exc.Status, request.RequestUri);      

            {           

                Log.InfoFormat("[{0}] {1}",request.Method,request.RequestUri);     

                Log.WarnFormat("[{0}] {1} {2}", request.Method, exc.Status,  request.RequestUri);     

using System.Reflection;

        private static readonly log4net.ILog Log = log4net.LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);

        "MsmKey" = "8:_928344C82AF3698D55890E76C45404A5"

        "OwnerKey" = "8:_8A9B95E5C0E945ECA7F21580A0D088D9"

        "MsmSig" = "8:_UNDEFINED"

        }

        "Entry"

        {

        "OwnerKey" = "8:_928344C82AF3698D55890E76C45404A5"

        "MsmSig" = "8:_UNDEFINED"

        }

        "Entry"

        {

        "MsmKey" = "8:_UNDEFINED"

            "{9F6F8455-1EF1-4B85-886A-4223BCC8E7F7}:_928344C82AF3698D55890E76C45404A5"

            {

            "AssemblyRegister" = "3:1"

            "AssemblyIsInGAC" = "11:FALSE"

            "AssemblyAsmDisplayName" = "8:AppLimit.NetSparkle.Net40, Version=1.0.83.0, Culture=neutral, processorArchitecture=MSIL"

                "ScatterAssemblies"

                {

                    "_928344C82AF3698D55890E76C45404A5"

                    {

                    "Name" = "8:AppLimit.NetSparkle.Net40.dll"

                    "Attributes" = "3:512"

                    }

                }

            "SourcePath" = "8:AppLimit.NetSparkle.Net40.dll"

            "TargetName" = "8:"

            "Tag" = "8:"

            "Folder" = "8:_FA3E4362540D4C76A5914763C178A3BD"

            "Condition" = "8:"

            "Transitive" = "11:FALSE"

            "Vital" = "11:TRUE"

            "ReadOnly" = "11:FALSE"

            "Hidden" = "11:FALSE"

            "System" = "11:FALSE"

            "Permanent" = "11:FALSE"

            "SharedLegacy" = "11:FALSE"

            "PackageAs" = "3:1"

            "Register" = "3:1"

            "Exclude" = "11:FALSE"

            "IsDependency" = "11:TRUE"

            "IsolateTo" = "8:"

            }

        "PackageCode" = "8:{A4185E8B-DEC9-4E52-BBE4-B959A8B30DD2}"

        "Title" = "8:Pithos [Version]"

Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Pithos.AppCast", "Pithos.AppCast", "{4ACC38DA-F81B-4DA5-A1AB-CEAAF3B7008A}"

	ProjectSection(SolutionItems) = preProject

		Pithos.AppCast\rnotes.css = Pithos.AppCast\rnotes.css

		Pithos.AppCast\versioninfo.xml = Pithos.AppCast\versioninfo.xml

	EndProjectSection

EndProject