Example #1
0
        public override void Close()
        {
            _fileMutex.WaitOne();
            try
            {
                string fileName = _name;

                // make sure it's all written out
                if (_indexOutput != null)
                {
                    _indexOutput.Flush();
                    _indexOutput.Close();
                }

                if (CacheDirectory.FileExists(fileName))
                {
                    //open stream to read cache file
                    using (var cacheStream = new StreamInput(CacheDirectory.OpenInput(fileName)))
                    // push the blobStream up to the master
                    using (var masterStream = new StreamOutput(MasterDirectory.CreateOutput(fileName)))
                    {
                        cacheStream.CopyTo(masterStream);

                        masterStream.Flush();
                        Trace.WriteLine(string.Format("PUT {1} bytes to {0} in cloud", _name, cacheStream.Length));
                    }

                    //sync the last file write times - at least get them close.
                    //TODO: The alternative would be to force both directory instances to be FSDirectory,
                    // or try casting the master directory to FSDirectory to get the raw FileInfo and manually
                    // set the lastmodified time - this should work though
                    MasterDirectory.TouchFile(fileName);
                    CacheDirectory.TouchFile(fileName);

            #if FULLDEBUG
                      Debug.WriteLine(string.Format("CLOSED WRITESTREAM {0}", _name));
            #endif
                }

                // clean up
                _indexOutput = null;
                GC.SuppressFinalize(this);
            }
            finally
            {
                _fileMutex.ReleaseMutex();
            }
        }
Example #2
0
        public SyncIndexInput(SyncDirectory directory, string name)
        {
            if (directory == null) throw new ArgumentNullException(nameof(directory));

            _name = name;
            _syncDirectory = directory;

            #if FULLDEBUG
            Trace.WriteLine(String.Format("opening {0} ", _name));
            #endif
            _fileMutex = SyncMutexManager.GrabMutex(_syncDirectory, _name);
            _fileMutex.WaitOne();
            try
            {
                var fileName = _name;

                var fFileNeeded = false;
                if (!CacheDirectory.FileExists(fileName))
                {
                    fFileNeeded = true;
                }
                else
                {
                    long cachedLength = CacheDirectory.FileLength(fileName);
                    long masterLength = MasterDirectory.FileLength(fileName);

                    if (cachedLength != masterLength)
                        fFileNeeded = true;
                    else
                    {
                        long cacheDate = CacheDirectory.FileModified(fileName);
                        long masterDate = MasterDirectory.FileModified(fileName);

                        //we need to compare to the second instead of by ticks because when we call
                        //TouchFile in SyncIndexOutput this won't set the files to be identical
                        DateTime start = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
                        var cachedLastModifiedUTC = start.AddMilliseconds(cacheDate).ToUniversalTime();
                        var masterLastModifiedUTC = start.AddMilliseconds(masterDate).ToUniversalTime();

                        if (cachedLastModifiedUTC != masterLastModifiedUTC)
                        {
                            var timeSpan = masterLastModifiedUTC.Subtract(cachedLastModifiedUTC);

                            //NOTE: This heavily depends on TouchFile in SyncIndexOutput which sets both the
                            //master and slave files to be 'Now', in theory this operation shouldn't
                            //make the file times any bigger than 1 second
                            if (timeSpan.TotalSeconds > 2)
                                fFileNeeded = true;
                            else
                            {
            #if FULLDEBUG
                                Debug.WriteLine(timeSpan.TotalSeconds);
            #endif
                                // file not needed
                            }
                        }
                    }
                }

                // if the file does not exist
                // or if it exists and it is older then the lastmodified time in the blobproperties (which always comes from the blob storage)
                if (fFileNeeded)
                {
                    //get the master file stream
                    using (var masterStream = new StreamInput(MasterDirectory.OpenInput(fileName)))
                    using (var cacheStream = _syncDirectory.CreateCachedOutputAsStream(fileName))
                    {
                        //copy this to the cached file stream
                        masterStream.CopyTo(cacheStream);

                        cacheStream.Flush();
                        Debug.WriteLine(string.Format("GET {0} RETREIVED {1} bytes", _name, cacheStream.Length));
                    }

                    // and open it as an input
                    _indexInput = CacheDirectory.OpenInput(fileName);
                }
                else
                {
            #if FULLDEBUG
                    Debug.WriteLine(String.Format("Using cached file for {0}", _name));
            #endif

                    // open the file in read only mode
                    _indexInput = CacheDirectory.OpenInput(fileName);
                }
            }
            finally
            {
                _fileMutex.ReleaseMutex();
            }
        }
Example #3
0
        public override void Close()
        {
            _fileMutex.WaitOne();
            try
            {
                string fileName = _name;

                // make sure it's all written out
                _indexOutput.Flush();

                long originalLength = _indexOutput.Length();
                _indexOutput.Close();

                Stream blobStream;

                // optionally put a compressor around the blob stream
                if (_azureDirectory.ShouldCompressFile(_name))
                {
                    blobStream = CompressStream(fileName, originalLength);
                }
                else
                {
                    blobStream = new StreamInput(CacheDirectory.OpenInput(fileName));
                }

                try
                {
                    // push the blobStream up to the cloud
                    _blob.UploadFromStream(blobStream);

                    // set the metadata with the original index file properties
                    _blob.Metadata["CachedLength"] = originalLength.ToString();
                    _blob.Metadata["CachedLastModified"] = CacheDirectory.FileModified(fileName).ToString();
                    _blob.SetMetadata();

                    Debug.WriteLine(string.Format("PUT {1} bytes to {0} in cloud", _name, blobStream.Length));
                }
                finally
                {
                    blobStream.Dispose();
                }

            #if FULLDEBUG
                Debug.WriteLine(string.Format("CLOSED WRITESTREAM {0}", _name));
            #endif
                // clean up
                _indexOutput = null;
                _blobContainer = null;
                _blob = null;
                GC.SuppressFinalize(this);
            }
            finally
            {
                _fileMutex.ReleaseMutex();
            }
        }
Example #4
0
        public SyncIndexInput(SyncDirectory directory, string name)
        {
            if (directory == null)
            {
                throw new ArgumentNullException(nameof(directory));
            }

            _name          = name;
            _syncDirectory = directory;

#if FULLDEBUG
            Trace.WriteLine(String.Format("opening {0} ", _name));
#endif
            _fileMutex = SyncMutexManager.GrabMutex(_syncDirectory, _name);
            _fileMutex.WaitOne();
            try
            {
                var fileName = _name;

                var fFileNeeded = false;
                if (!CacheDirectory.FileExists(fileName))
                {
                    fFileNeeded = true;
                }
                else
                {
                    long cachedLength = CacheDirectory.FileLength(fileName);
                    long masterLength = MasterDirectory.FileLength(fileName);

                    if (cachedLength != masterLength)
                    {
                        fFileNeeded = true;
                    }
                    else
                    {
                        long cacheDate  = CacheDirectory.FileModified(fileName);
                        long masterDate = MasterDirectory.FileModified(fileName);

                        //we need to compare to the second instead of by ticks because when we call
                        //TouchFile in SyncIndexOutput this won't set the files to be identical
                        DateTime start = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
                        var      cachedLastModifiedUTC = start.AddMilliseconds(cacheDate).ToUniversalTime();
                        var      masterLastModifiedUTC = start.AddMilliseconds(masterDate).ToUniversalTime();

                        if (cachedLastModifiedUTC != masterLastModifiedUTC)
                        {
                            var timeSpan = masterLastModifiedUTC.Subtract(cachedLastModifiedUTC);

                            //NOTE: This heavily depends on TouchFile in SyncIndexOutput which sets both the
                            //master and slave files to be 'Now', in theory this operation shouldn't
                            //make the file times any bigger than 1 second
                            if (timeSpan.TotalSeconds > 2)
                            {
                                fFileNeeded = true;
                            }
                            else
                            {
#if FULLDEBUG
                                Debug.WriteLine(timeSpan.TotalSeconds);
#endif
                                // file not needed
                            }
                        }
                    }
                }

                // if the file does not exist
                // or if it exists and it is older then the lastmodified time in the blobproperties (which always comes from the blob storage)
                if (fFileNeeded)
                {
                    //get the master file stream
                    using (var masterStream = new StreamInput(MasterDirectory.OpenInput(fileName)))
                        using (var cacheStream = _syncDirectory.CreateCachedOutputAsStream(fileName))
                        {
                            //copy this to the cached file stream
                            masterStream.CopyTo(cacheStream);

                            cacheStream.Flush();
                            Debug.WriteLine(string.Format("GET {0} RETREIVED {1} bytes", _name, cacheStream.Length));
                        }

                    // and open it as an input
                    _indexInput = CacheDirectory.OpenInput(fileName);
                }
                else
                {
#if FULLDEBUG
                    Debug.WriteLine(String.Format("Using cached file for {0}", _name));
#endif

                    // open the file in read only mode
                    _indexInput = CacheDirectory.OpenInput(fileName);
                }
            }
            finally
            {
                _fileMutex.ReleaseMutex();
            }
        }