Exemple #1
0
        public MetadataCache(string name, string path, Action <IEnumerable <Metadata>, RuntimeInfo> entriesAdded)
        {
            this.name          = name;
            this.path          = path;
            this.catalogReader = new InfiniteFileReader(path, StoreCommon.GetCatalogFileName(name));
            this.entriesAdded  = entriesAdded;

            // assume v0 for backwards compat. Update will fix this up if the file is newer.
            this.runtimeVersion = new RuntimeInfo(0);
            this.Update();
        }
Exemple #2
0
        /// <summary>
        /// Initializes a new instance of the <see cref="StoreWriter"/> class.
        /// </summary>
        /// <param name="name">The name of the application that generated the persisted files, or the root name of the files.</param>
        /// <param name="path">The directory in which to create the partition, or null to create a volatile data store.</param>
        /// <param name="createSubdirectory">If true, a numbered sub-directory is created for this store.</param>
        /// <param name="append">If true, the store is opened in append mode.</param>
        public StoreWriter(string name, string path, bool createSubdirectory = true, bool append = false)
        {
            this.name   = name;
            this.append = append;
            if (path != null)
            {
                int id = 0;
                this.path = System.IO.Path.GetFullPath(path);
                if (createSubdirectory)
                {
                    // if the root directory already exists, look for the next available id
                    if (Directory.Exists(this.path))
                    {
                        var existingIds = Directory.EnumerateDirectories(this.path, this.name + ".????")
                                          .Select(d => d.Split('.').Last())
                                          .Where(
                            n =>
                        {
                            int i;
                            return(int.TryParse(n, out i));
                        })
                                          .Select(n => int.Parse(n));

                        id = (existingIds.Count() == 0) ? 0 : existingIds.Max() + 1;
                    }

                    this.path = System.IO.Path.Combine(this.path, $"{this.name}.{id:0000}");
                }

                if (!Directory.Exists(this.path))
                {
                    Directory.CreateDirectory(this.path);
                }
            }

            this.catalogWriter   = new InfiniteFileWriter(this.path, StoreCommon.GetCatalogFileName(this.name), CatalogExtentSize, append);
            this.pageIndexWriter = new InfiniteFileWriter(this.path, StoreCommon.GetIndexFileName(this.name), IndexExtentSize, append);
            this.writer          = new MessageWriter(StoreCommon.GetDataFileName(this.name), this.path, append);

            // write the first index entry
            this.UpdatePageIndex(0, default(Envelope));
        }
Exemple #3
0
        /// <summary>
        /// Indicates whether the specified data store has an active writer.
        /// </summary>
        /// <param name="storeName">The store name.</param>
        /// <param name="storePath">The store path.</param>
        /// <returns>Returns true if there is an active data file writer to this store.</returns>
        public static bool IsStoreLive(string storeName, string storePath)
        {
            Mutex writerActiveMutex;

            if (!Mutex.TryOpenExisting(InfiniteFileWriter.ActiveWriterMutexName(storePath, StoreCommon.GetCatalogFileName(storeName)), out writerActiveMutex))
            {
                return(false);
            }

            writerActiveMutex.Dispose();
            return(true);
        }