/// <summary>
/// Initializes a new instance of the <see cref="StoreReader"/> class.
/// This provides a fast way to create a reader,
/// by reusing the metadata and index already loaded by an existing store reader.
/// </summary>
/// <param name="other">Another reader pointing to the same store.</param>
public StoreReader(StoreReader other)
{
this.name = other.Name;
this.path = other.Path;
this.autoOpenAllStreams = other.AutoOpenAllStreams;
this.messageReader = new MessageReader(StoreCommon.GetDataFileName(this.name), this.path);
this.largeMessageReader = new MessageReader(StoreCommon.GetLargeDataFileName(this.name), this.path);
this.indexCache = other.indexCache.AddRef();
this.metadataCache = other.metadataCache.AddRef();
}
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();
}
/// <summary>
/// Initializes a new instance of the <see cref="StoreReader"/> 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 the main persisted file resides or will reside, or null to create a volatile data store.</param>
/// <param name="metadataUpdateHandler">Delegate to call.</param>
/// <param name="autoOpenAllStreams">Automatically open all streams.</param>
public StoreReader(string name, string path, Action <IEnumerable <Metadata>, RuntimeInfo> metadataUpdateHandler, bool autoOpenAllStreams = false)
{
this.name = name;
this.path = StoreCommon.GetPathToLatestVersion(name, path);
this.autoOpenAllStreams = autoOpenAllStreams;
// open the data readers
this.messageReader = new MessageReader(StoreCommon.GetDataFileName(this.name), this.path);
this.largeMessageReader = new MessageReader(StoreCommon.GetLargeDataFileName(this.name), this.path);
this.indexCache = Shared.Create(new PageIndexCache(name, this.path));
this.metadataCache = Shared.Create(new MetadataCache(name, this.path, metadataUpdateHandler));
}
/// <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));
}
public PageIndexCache(string name, string path)
{
this.indexReader = new InfiniteFileReader(path, StoreCommon.GetIndexFileName(name));
}
/// <summary>
/// Creates a logical storage stream to write messages to.
/// </summary>
/// <param name="streamId">The id of the stream, unique for this store. All messages with this stream id will be written to this storage stream.</param>
/// <param name="streamName">The name of the stream. This name can be later used to open the sorage stream for reading.</param>
/// <param name="indexed">Indicates whether the stream is indexed or not. Indexed streams have a small index entry in the main data file and the actual message body in a large data file.</param>
/// <param name="typeName">A name identifying the type of the messages in this stream. This is usually a fully-qualified type name or a data contract name, but can be anything that the caller wants.</param>
/// <returns>The complete metadata for the storage stream just created.</returns>
public PsiStreamMetadata OpenStream(int streamId, string streamName, bool indexed, string typeName)
{
if (this.metadata.ContainsKey(streamId))
{
throw new InvalidOperationException($"The stream id {streamId} has already been registered with this writer.");
}
var meta = new PsiStreamMetadata(streamName, streamId, typeName);
meta.Opened = Time.GetCurrentTime();
meta.IsPersisted = true;
meta.IsIndexed = indexed;
meta.PartitionName = this.name;
meta.PartitionPath = this.path;
this.metadata[streamId] = meta;
this.WriteToCatalog(meta);
// make sure we have a large file if needed
if (indexed)
{
this.largeMessageWriter = this.largeMessageWriter ?? new MessageWriter(StoreCommon.GetLargeDataFileName(this.name), this.path, this.append);
}
return(meta);
}
/// <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);
}