コード例 #1
0
        /// <summary>
        /// Creates a new file, with the correct naming scheme.
        /// </summary>
        /// <param name="fileInfo">The <see cref="ProlificDataFileInfo"/> instance representing the name of the file created.</param>
        /// <param name="useWriteThroughIfSupported"><c>true</c> to try to use <see cref="IFileSystemWriter.CreateWriteThroughBinary"/> instead of <see cref="IFileSystemWriter.CreateNewBinary"/>.</param>
        /// <returns>The <see cref="IBinaryWriter"/> representing the file created.</returns>
        public IBinaryWriter CreateFile( out ProlificDataFileInfo fileInfo, bool useWriteThroughIfSupported = false )
        {
            Ensure.That(this).NotDisposed();

            bool writeThroughSupported = false;
            if( useWriteThroughIfSupported )
                writeThroughSupported = this.fileSystem.SupportsCreateWriteThroughBinary;

            // we may have to try multiple times, if we don't yet have an
            // app instance ID, that's verified to be unique
            while( true )
            {
                string appID = appInstanceID;
                bool isNewAppID = false;
                if( appID.NullReference() )
                {
                    // NOTE: random does not necessarily mean unique. But since I find it unlikely to
                    //       have even a few dozen hashes at the same time, we should be in the clear:
                    //       32^6 ~= 1+ billion; and we probably wouldn't see conflicts before we had
                    //       40000-50000 hashes present at the same time. Based on an answer here:
                    //       http://stackoverflow.com/a/9543797
                    appID = GenerateRandomHash(DefaultAppIDLength);
                    isNewAppID = true;
                }

                // try to create the file
                var file = ToFileInfo(this.fileManagerID, appID, this.fileExtension, this.fileSystem.EscapesNames);
                IBinaryWriter fileStream;
                try
                {
                    if( useWriteThroughIfSupported && writeThroughSupported )
                        fileStream = this.fileSystem.CreateWriteThroughBinary(file.DataStoreName, overwriteIfExists: false);
                    else
                        fileStream = this.fileSystem.CreateNewBinary(file.DataStoreName, overwriteIfExists: false);
                }
                catch( Exception ex )
                {
                    //// the file already exists, or there was another problem

                    bool fileAlreadyExists;
                    try
                    {
                        fileAlreadyExists = FindAllFiles(this.fileSystem)
                            .Where(f => DataStore.Comparer.Equals(f.DataStoreName, file.DataStoreName))
                            .FirstOrNullable()
                            .HasValue;
                    }
                    catch( Exception exx )
                    {
                        // there is definitely a problem with the file system: report both exceptions
                        throw new AggregateException("Failed to create file!", ex, exx).StoreFileLine();
                    }

                    if( fileAlreadyExists )
                    {
                        //// NOTE: we are assuming here, that files created by the same source,
                        ////       in the same app instance, are at least a minute apart.

                        // try again with a new app instance ID
                        continue;
                    }
                    else
                    {
                        ex.StoreFileLine();
                        throw; // there was some kind of problem, trying to create the file...
                    }
                }

                // alright, we successfully created the file, but that does not mean, that
                // the app instance ID was not already in use, sometime before that
                if( isNewAppID )
                {
                    bool appIDAlreadyInUse = FindAllFiles(this.fileSystem)
                        .Where(f => !DataStore.Comparer.Equals(f.DataStoreName, file.DataStoreName))
                        .Where(f => AppInstanceIDComparer.Equals(f.AppInstanceID, appID))
                        .FirstOrNullable()
                        .HasValue;

                    if( appIDAlreadyInUse )
                    {
                        // remove this file to avoid confusion, and try again
                        this.fileSystem.DeleteFile(file.DataStoreName);
                        continue;
                    }
                    else
                    {
                        // a new and unique app ID was found
                        var prevAppID = Interlocked.CompareExchange(ref appInstanceID, appID, comparand: null);
                        if( !prevAppID.NullReference() )
                        {
                            // however, this method was called concurrently, and another unique app ID was already established
                            // clean up, and try again with that ID
                            this.fileSystem.DeleteFile(file.DataStoreName);
                            continue;
                        }
                    }
                }

                // either the app ID was not generated just now,
                // or it was, and we successfully saved it
                fileInfo = file;
                return fileStream;
            }
        }
コード例 #2
0
        private static bool TryParseDataStoreName( string dataStoreName, bool escapesFileNames, out ProlificDataFileInfo fileInfo )
        {
            if( dataStoreName.NullOrEmpty() )
            {
                fileInfo = default(ProlificDataFileInfo);
                return false;
            }

            string fileName = escapesFileNames ? DataStore.UnescapeName(dataStoreName) : dataStoreName;
            string[] parts = fileName.Split(new char[] { '_' }, StringSplitOptions.None);
            if( parts.Length != 3 )
            {
                fileInfo = default(ProlificDataFileInfo);
                return false;
            }

            string fileManagerID = parts[0];
            string creationTimeString = parts[1];
            string appInstanceID = parts[2];
            string fileExtension = null;

            if( escapesFileNames
             && appInstanceID.Length > DefaultAppIDLength )
            {
                fileExtension = appInstanceID.Substring(startIndex: DefaultAppIDLength + 1);
                appInstanceID = appInstanceID.Substring(startIndex: 0, length: DefaultAppIDLength);
            }

            DateTime creationTime;
            if( !DateTime.TryParseExact(creationTimeString, CreationTimeFormat, CultureInfo.InvariantCulture, DateTimeStyles.AssumeUniversal | DateTimeStyles.AdjustToUniversal, out creationTime) )
            {
                fileInfo = default(ProlificDataFileInfo);
                return false;
            }

            fileInfo = new ProlificDataFileInfo(fileManagerID, appInstanceID, creationTime, fileExtension, dataStoreName);
            return true;
        }