public MongoGridFSStream(
MongoGridFSFileInfo fileInfo,
FileMode mode
)
: this(fileInfo, mode, FileAccess.ReadWrite)
{
}
public void TestEquals()
{
var settings = new MongoGridFSSettings();
var createOptions = new MongoGridFSCreateOptions { ChunkSize = 123 };
var a1 = new MongoGridFSFileInfo(_server, _server.Primary, _database.Name, settings, "f", createOptions);
var a2 = new MongoGridFSFileInfo(_server, _server.Primary, _database.Name, settings, "f", createOptions);
var a3 = a2;
var b = new MongoGridFSFileInfo(_server, _server.Primary, _database.Name, settings, "g", createOptions);
var null1 = (MongoGridFSFileInfo)null;
var null2 = (MongoGridFSFileInfo)null;
Assert.NotSame(a1, a2);
Assert.Same(a2, a3);
Assert.True(a1.Equals((object)a2));
Assert.False(a1.Equals((object)null));
Assert.False(a1.Equals((object)"x"));
Assert.True(a1 == a2);
Assert.True(a2 == a3);
Assert.False(a1 == b);
Assert.False(a1 == null1);
Assert.False(null1 == a1);
Assert.True(null1 == null2);
Assert.False(a1 != a2);
Assert.False(a2 != a3);
Assert.True(a1 != b);
Assert.True(a1 != null1);
Assert.True(null1 != a1);
Assert.False(null1 != null2);
Assert.Equal(a1.GetHashCode(), a2.GetHashCode());
}
public void TestEquals()
{
var createOptions = new MongoGridFSCreateOptions { ChunkSize = 123 };
var a = new MongoGridFSFileInfo(gridFS, "f", createOptions);
var b = new MongoGridFSFileInfo(gridFS, "f", createOptions);
var c = new MongoGridFSFileInfo(gridFS, "g", createOptions);
var n = (MongoCredentials) null;
Assert.IsTrue(object.Equals(a, b));
Assert.IsFalse(object.Equals(a, c));
Assert.IsFalse(a.Equals(n));
Assert.IsFalse(a.Equals(null));
Assert.IsTrue(a == b);
Assert.IsFalse(a == c);
Assert.IsFalse(a == null);
Assert.IsFalse(null == a);
Assert.IsTrue(n == null);
Assert.IsTrue(null == n);
Assert.IsFalse(a != b);
Assert.IsTrue(a != c);
Assert.IsTrue(a != null);
Assert.IsTrue(null != a);
Assert.IsFalse(n != null);
Assert.IsFalse(null != n);
}
public void TestCreateWithRemoteFileNameAndCreateOptions()
{
var aliases = new string[] { "a", "b" };
var uploadDate = new DateTime(2011, 11, 10, 19, 57, 0, DateTimeKind.Utc);
var metadata = new BsonDocument("x", 1);
var createOptions = new MongoGridFSCreateOptions()
{
Aliases = aliases,
ChunkSize = 123,
ContentType = "content",
Id = 1,
Metadata = metadata,
UploadDate = uploadDate
};
var info = new MongoGridFSFileInfo(_gridFS, "filename", createOptions);
Assert.IsTrue(aliases.SequenceEqual(info.Aliases));
Assert.AreEqual(123, info.ChunkSize);
Assert.AreEqual("content", info.ContentType);
Assert.AreEqual(_gridFS, info.GridFS);
Assert.AreEqual(1, info.Id.AsInt32);
Assert.AreEqual(0, info.Length);
Assert.AreEqual(null, info.MD5);
Assert.AreEqual(metadata, info.Metadata);
Assert.AreEqual("filename", info.Name);
Assert.AreEqual(uploadDate, info.UploadDate);
}
public void TestEquals()
{
var createOptions = new MongoGridFSCreateOptions { ChunkSize = 123 };
var a1 = new MongoGridFSFileInfo(_gridFS, "f", createOptions);
var a2 = new MongoGridFSFileInfo(_gridFS, "f", createOptions);
var a3 = a2;
var b = new MongoGridFSFileInfo(_gridFS, "g", createOptions);
var null1 = (MongoGridFSFileInfo)null;
var null2 = (MongoGridFSFileInfo)null;
Assert.AreNotSame(a1, a2);
Assert.AreSame(a2, a3);
Assert.IsTrue(a1.Equals((object)a2));
Assert.IsFalse(a1.Equals((object)null));
Assert.IsFalse(a1.Equals((object)"x"));
Assert.IsTrue(a1 == a2);
Assert.IsTrue(a2 == a3);
Assert.IsFalse(a1 == b);
Assert.IsFalse(a1 == null1);
Assert.IsFalse(null1 == a1);
Assert.IsTrue(null1 == null2);
Assert.IsFalse(a1 != a2);
Assert.IsFalse(a2 != a3);
Assert.IsTrue(a1 != b);
Assert.IsTrue(a1 != null1);
Assert.IsTrue(null1 != a1);
Assert.IsFalse(null1 != null2);
Assert.AreEqual(a1.GetHashCode(), a2.GetHashCode());
}
} // End Sub CreateIndex
// Following example show how to save file and read back from gridfs(using official mongodb driver):
// http://www.mongovue.com/
public void Test()
{
MongoDB.Driver.MongoServer server = MongoServer.Create("mongodb://localhost:27020");
MongoDB.Driver.MongoDatabase database = server.GetDatabase("tesdb");
string fileName = "D:\\Untitled.png";
string newFileName = "D:\\new_Untitled.png";
using (System.IO.FileStream fs = new System.IO.FileStream(fileName, System.IO.FileMode.Open))
{
MongoDB.Driver.GridFS.MongoGridFSFileInfo gridFsInfo = database.GridFS.Upload(fs, fileName);
BsonValue fileId = gridFsInfo.Id;
ObjectId oid = new ObjectId(fileId.AsByteArray);
MongoDB.Driver.GridFS.MongoGridFSFileInfo file = database.GridFS.FindOne(Query.EQ("_id", oid));
using (System.IO.Stream stream = file.OpenRead())
{
byte[] bytes = new byte[stream.Length];
stream.Read(bytes, 0, (int)stream.Length);
using (System.IO.FileStream newFs = new System.IO.FileStream(newFileName, System.IO.FileMode.Create))
{
newFs.Write(bytes, 0, bytes.Length);
} // End Using newFs
} // End Using stream
} // End using fs
} // End Sub Test
internal MongoStorageFile(MongoGridFSFileInfo fileInfo )
{
if (fileInfo == null)
throw new ArgumentNullException("fileInfo");
this.fileInfo = fileInfo;
}
public GridFsBlobDescriptor(BlobId blobId, MongoGridFSFileInfo mongoGridFsFileInfo)
{
if (mongoGridFsFileInfo == null) throw new ArgumentNullException("mongoGridFsFileInfo");
_mongoGridFsFileInfo = mongoGridFsFileInfo;
BlobId = blobId;
FileNameWithExtension = new FileNameWithExtension(_mongoGridFsFileInfo.Name);
}
/// <summary>
/// Opens a GridFS file with the specified mode.
/// </summary>
/// <param name="remoteFileName">The remote file name.</param>
/// <param name="mode">The mode.</param>
/// <returns>A stream.</returns>
public MongoGridFSStream Open(
string remoteFileName,
FileMode mode
)
{
var fileInfo = new MongoGridFSFileInfo(this, remoteFileName);
return(fileInfo.Open(mode));
}
/// <summary>
/// Sets the metadata for an existing GridFS file.
/// </summary>
/// <param name="fileInfo">The GridFS file.</param>
/// <param name="metadata">The metadata.</param>
public void SetMetadata(MongoGridFSFileInfo fileInfo, BsonValue metadata)
{
var database = GetDatabase(ReadPreference.Primary);
var filesCollection = GetFilesCollection(database);
var query = Query.EQ("_id", fileInfo.Id);
var update = (metadata == null) ? Update.Unset("metadata") : Update.Set("metadata", metadata);
filesCollection.Update(query, update, _settings.WriteConcern);
}
/// <summary>
/// Opens a GridFS file with the specified mode and access.
/// </summary>
/// <param name="remoteFileName">The remote file name.</param>
/// <param name="mode">The mode.</param>
/// <param name="access">The access.</param>
/// <returns>A stream.</returns>
public MongoGridFSStream Open(string remoteFileName, FileMode mode, FileAccess access)
{
using (_server.RequestStart(null, DetermineReadPreference(mode, access)))
{
var serverInstance = _server.RequestConnection.ServerInstance;
var fileInfo = new MongoGridFSFileInfo(_server, serverInstance, _databaseName, _settings, remoteFileName);
return(fileInfo.Open(mode, access));
}
}
/// <summary>
/// Opens an existing GridFS file for reading.
/// </summary>
/// <param name="remoteFileName">The remote file name.</param>
/// <returns>A stream.</returns>
public MongoGridFSStream OpenRead(string remoteFileName)
{
using (_server.RequestStart(null, _settings.ReadPreference))
{
var serverInstance = _server.RequestConnection.ServerInstance;
var fileInfo = new MongoGridFSFileInfo(_server, serverInstance, _databaseName, _settings, remoteFileName);
return(fileInfo.OpenRead());
}
}
/// <summary>
/// Creates or opens a GridFS file for writing UTF-8 encoded text.
/// </summary>
/// <param name="remoteFileName">The remote file name.</param>
/// <param name="createOptions">The create options.</param>
/// <returns>A stream writer.</returns>
public StreamWriter CreateText(
string remoteFileName,
MongoGridFSCreateOptions createOptions
)
{
var fileInfo = new MongoGridFSFileInfo(this, remoteFileName, createOptions);
return(fileInfo.CreateText());
}
/// <summary>
/// Sets the content type for an existing GridFS file.
/// </summary>
/// <param name="fileInfo">The GridFS file.</param>
/// <param name="contentType">The content type.</param>
public void SetContentType(MongoGridFSFileInfo fileInfo, string contentType)
{
var database = GetDatabase(ReadPreference.Primary);
var filesCollection = GetFilesCollection(database);
var query = Query.EQ("_id", fileInfo.Id);
var update = (contentType == null) ? Update.Unset("contentType") : Update.Set("contentType", contentType);
filesCollection.Update(query, update, _settings.WriteConcern);
}
/// <summary>
/// Opens an existing GridFS file for writing.
/// </summary>
/// <param name="remoteFileName">The remote file name.</param>
/// <param name="createOptions">The create options.</param>
/// <returns>A stream.</returns>
public MongoGridFSStream OpenWrite(
string remoteFileName,
MongoGridFSCreateOptions createOptions
)
{
var fileInfo = new MongoGridFSFileInfo(this, remoteFileName, createOptions);
return(fileInfo.OpenWrite());
}
/// <summary>
/// Downloads a GridFS file.
/// </summary>
/// <param name="stream">The destination stream.</param>
/// <param name="fileInfo">The GridFS file.</param>
public void Download(Stream stream, MongoGridFSFileInfo fileInfo)
{
using (_server.RequestStart(_settings.ReadPreference))
{
var connectionId = _server.RequestConnectionId;
if (_settings.VerifyMD5 && fileInfo.MD5 == null)
{
throw new MongoGridFSException(connectionId, "VerifyMD5 is true and file being downloaded has no MD5 hash.");
}
var database = GetDatabase();
var chunksCollection = GetChunksCollection(database);
string md5Client = null;
using (var md5Algorithm = _settings.VerifyMD5 ? MD5.Create() : null)
{
var numberOfChunks = (fileInfo.Length + fileInfo.ChunkSize - 1) / fileInfo.ChunkSize;
for (var n = 0L; n < numberOfChunks; n++)
{
var query = Query.And(Query.EQ("files_id", fileInfo.Id), Query.EQ("n", n));
var chunk = chunksCollection.FindOne(query);
if (chunk == null)
{
string errorMessage = string.Format("Chunk {0} missing for GridFS file '{1}'.", n, fileInfo.Name);
throw new MongoGridFSException(connectionId, errorMessage);
}
var data = chunk["data"].AsBsonBinaryData;
if (data.Bytes.Length != fileInfo.ChunkSize)
{
// the last chunk only has as many bytes as needed to complete the file
if (n < numberOfChunks - 1 || data.Bytes.Length != fileInfo.Length % fileInfo.ChunkSize)
{
string errorMessage = string.Format("Chunk {0} for GridFS file '{1}' is the wrong size.", n, fileInfo.Name);
throw new MongoGridFSException(connectionId, errorMessage);
}
}
stream.Write(data.Bytes, 0, data.Bytes.Length);
if (_settings.VerifyMD5)
{
md5Algorithm.TransformBlock(data.Bytes, 0, data.Bytes.Length, null, 0);
}
}
if (_settings.VerifyMD5)
{
md5Algorithm.TransformFinalBlock(new byte[0], 0, 0);
md5Client = BsonUtils.ToHexString(md5Algorithm.Hash);
}
}
if (_settings.VerifyMD5 && !md5Client.Equals(fileInfo.MD5, StringComparison.OrdinalIgnoreCase))
{
throw new MongoGridFSException(connectionId, "Download client and server MD5 hashes are not equal.");
}
}
}
/// <summary>
/// Opens an existing UTF-8 encoded text GridFS file for reading.
/// </summary>
/// <param name="remoteFileName">The remote file name.</param>
/// <returns>A stream reader.</returns>
public StreamReader OpenText(string remoteFileName)
{
using (_server.RequestStart(_settings.ReadPreference))
{
var serverInstance = _server.RequestServerInstance;
var fileInfo = new MongoGridFSFileInfo(_server, serverInstance, _databaseName, _settings, remoteFileName);
return(fileInfo.OpenText());
}
}
/// <summary>
/// Creates or opens a GridFS file for writing UTF-8 encoded text.
/// </summary>
/// <param name="remoteFileName">The remote file name.</param>
/// <returns>A stream writer.</returns>
public StreamWriter CreateText(string remoteFileName)
{
using (_server.RequestStart(null, ReadPreference.Primary))
{
var serverInstance = _server.RequestConnection.ServerInstance;
var fileInfo = new MongoGridFSFileInfo(_server, serverInstance, _databaseName, _settings, remoteFileName);
return(fileInfo.CreateText());
}
}
/// <summary>
/// Sets the aliases for an existing GridFS file.
/// </summary>
/// <param name="fileInfo">The GridFS file.</param>
/// <param name="aliases">The aliases.</param>
public void SetAliases(MongoGridFSFileInfo fileInfo, string[] aliases)
{
var database = GetDatabase(ReadPreference.Primary);
var filesCollection = GetFilesCollection(database);
var query = Query.EQ("_id", fileInfo.Id);
var update = (aliases == null) ? Update.Unset("aliases") : Update.Set("aliases", new BsonArray(aliases));
filesCollection.Update(query, update, _settings.WriteConcern);
}
/// <summary>
/// Downloads a GridFS file.
/// </summary>
/// <param name="localFileName">The local file name.</param>
/// <param name="fileInfo">The GridFS file.</param>
public void Download(
string localFileName,
MongoGridFSFileInfo fileInfo
)
{
using (Stream stream = File.Create(localFileName)) {
Download(stream, fileInfo);
}
}
/// <summary>
/// Sets the aliases for an existing GridFS file.
/// </summary>
/// <param name="fileInfo">The GridFS file.</param>
/// <param name="aliases">The aliases.</param>
public void SetAliases(
MongoGridFSFileInfo fileInfo,
string[] aliases
)
{
var query = Query.EQ("_id", fileInfo.Id);
var update = (aliases == null) ? Update.Unset("aliases") : Update.Set("aliases", BsonArray.Create((IEnumerable <string>)aliases));
files.Update(query, update);
}
/// <summary>
/// Sets the content type for an existing GridFS file.
/// </summary>
/// <param name="fileInfo">The GridFS file.</param>
/// <param name="contentType">The content type.</param>
public void SetContentType(
MongoGridFSFileInfo fileInfo,
string contentType
)
{
var query = Query.EQ("_id", fileInfo.Id);
var update = (contentType == null) ? Update.Unset("contentType") : Update.Set("contentType", contentType);
files.Update(query, update);
}
public static FileModel FileModelFromGridFSMetadata(MongoGridFSFileInfo gfs_entry)
{
var file_model = new FileModel();
file_model.Filename = gfs_entry.Metadata["Filename"].AsString;
file_model.PatientID = gfs_entry.Metadata["PatientID"].AsString;
file_model.ID = gfs_entry.Id.AsObjectId;
return file_model;
}
/// <summary>
/// Sets the metadata for an existing GridFS file.
/// </summary>
/// <param name="fileInfo">The GridFS file.</param>
/// <param name="metadata">The metadata.</param>
public void SetMetadata(
MongoGridFSFileInfo fileInfo,
BsonValue metadata
)
{
var query = Query.EQ("_id", fileInfo.Id);
var update = (metadata == null) ? Update.Unset("metadata") : Update.Set("metadata", metadata);
files.Update(query, update);
}
/// <summary>
/// Opens a GridFS file with the specified mode, access and create options.
/// </summary>
/// <param name="remoteFileName">The remote file name.</param>
/// <param name="mode">The mode.</param>
/// <param name="access">The access.</param>
/// <param name="createOptions">The create options.</param>
/// <returns>A stream.</returns>
public MongoGridFSStream Open(
string remoteFileName,
FileMode mode,
FileAccess access,
MongoGridFSCreateOptions createOptions)
{
var fileInfo = new MongoGridFSFileInfo(this, remoteFileName, createOptions);
return(fileInfo.Open(mode, access));
}
/// <summary>
/// Creates or opens a GridFS file for writing UTF-8 encoded text.
/// </summary>
/// <param name="remoteFileName">The remote file name.</param>
/// <param name="createOptions">The create options.</param>
/// <returns>A stream writer.</returns>
public StreamWriter CreateText(string remoteFileName, MongoGridFSCreateOptions createOptions)
{
if (_settings.ReadPreference != ReadPreference.Primary)
{
var gridFS = GetPrimaryGridFSSettings();
return(gridFS.CreateText(remoteFileName, createOptions));
}
using (_server.RequestStart(null, ReadPreference.Primary))
{
var serverInstance = _server.RequestConnection.ServerInstance;
var fileInfo = new MongoGridFSFileInfo(_server, serverInstance, _databaseName, _settings, remoteFileName, createOptions);
return(fileInfo.CreateText());
}
}
/// <summary>
/// Opens an existing GridFS file for writing.
/// </summary>
/// <param name="remoteFileName">The remote file name.</param>
/// <returns>A stream.</returns>
public MongoGridFSStream OpenWrite(string remoteFileName)
{
if (_settings.ReadPreference != ReadPreference.Primary)
{
var gridFS = GetPrimaryGridFSSettings();
return(gridFS.OpenWrite(remoteFileName));
}
using (_server.RequestStart(null, ReadPreference.Primary))
{
var serverInstance = _server.RequestConnection.ServerInstance;
var fileInfo = new MongoGridFSFileInfo(_server, serverInstance, _databaseName, _settings, remoteFileName);
return(fileInfo.OpenWrite());
}
}
/// <summary>
/// Opens an existing GridFS file for writing.
/// </summary>
/// <param name="remoteFileName">The remote file name.</param>
/// <param name="createOptions">The create options.</param>
/// <returns>A stream.</returns>
public MongoGridFSStream OpenWrite(string remoteFileName, MongoGridFSCreateOptions createOptions)
{
if (_settings.ReadPreference != ReadPreference.Primary)
{
var gridFS = WithReadPreferencePrimary();
return(gridFS.OpenWrite(remoteFileName, createOptions));
}
using (_server.RequestStart(ReadPreference.Primary))
{
var serverInstance = _server.RequestServerInstance;
var fileInfo = new MongoGridFSFileInfo(_server, serverInstance, _databaseName, _settings, remoteFileName, createOptions);
return(fileInfo.OpenWrite());
}
}
/// <summary>
/// Creates or opens a GridFS file for writing UTF-8 encoded text.
/// </summary>
/// <param name="remoteFileName">The remote file name.</param>
/// <returns>A stream writer.</returns>
public StreamWriter CreateText(string remoteFileName)
{
if (_settings.ReadPreference != ReadPreference.Primary)
{
var gridFS = WithReadPreferencePrimary();
return(gridFS.CreateText(remoteFileName));
}
using (_server.RequestStart(ReadPreference.Primary))
{
var serverInstance = _server.RequestServerInstance;
var fileInfo = new MongoGridFSFileInfo(_server, serverInstance, _databaseName, _settings, remoteFileName);
return(fileInfo.CreateText());
}
}
/// <summary>
/// Downloads a GridFS file.
/// </summary>
/// <param name="stream">The destination stream.</param>
/// <param name="fileInfo">The GridFS file.</param>
public void Download(
Stream stream,
MongoGridFSFileInfo fileInfo
)
{
using (database.RequestStart()) {
EnsureIndexes();
string md5Client;
using (var md5Algorithm = MD5.Create()) {
var numberOfChunks = (fileInfo.Length + fileInfo.ChunkSize - 1) / fileInfo.ChunkSize;
for (int n = 0; n < numberOfChunks; n++)
{
var query = Query.And(
Query.EQ("files_id", fileInfo.Id),
Query.EQ("n", n)
);
var chunk = chunks.FindOne(query);
if (chunk == null)
{
string errorMessage = string.Format("Chunk {0} missing for GridFS file '{1}'.", n, fileInfo.Name);
throw new MongoGridFSException(errorMessage);
}
var data = chunk["data"].AsBsonBinaryData;
if (data.Bytes.Length != fileInfo.ChunkSize)
{
// the last chunk only has as many bytes as needed to complete the file
if (n < numberOfChunks - 1 || data.Bytes.Length != fileInfo.Length % fileInfo.ChunkSize)
{
string errorMessage = string.Format("Chunk {0} for GridFS file '{1}' is the wrong size.", n, fileInfo.Name);
throw new MongoGridFSException(errorMessage);
}
}
stream.Write(data.Bytes, 0, data.Bytes.Length);
md5Algorithm.TransformBlock(data.Bytes, 0, data.Bytes.Length, null, 0);
}
md5Algorithm.TransformFinalBlock(new byte[0], 0, 0);
md5Client = BsonUtils.ToHexString(md5Algorithm.Hash);
}
if (!md5Client.Equals(fileInfo.MD5, StringComparison.OrdinalIgnoreCase))
{
throw new MongoGridFSException("Download client and server MD5 hashes are not equal.");
}
}
}
/// <summary>
/// Compares this MongoGridFSFileInfo to another MongoGridFSFileInfo.
/// </summary>
/// <param name="rhs">The other MongoGridFSFileInfo.</param>
/// <returns>True if the two MongoGridFSFileInfos are equal.</returns>
public bool Equals(
MongoGridFSFileInfo rhs
)
{
if (rhs == null)
{
return(false);
}
return
((this.aliases == null && rhs.aliases == null || this.aliases != null && rhs.aliases != null && this.aliases.SequenceEqual(rhs.aliases)) &&
this.chunkSize == rhs.chunkSize &&
this.contentType == rhs.contentType &&
this.id == rhs.id &&
this.length == rhs.length &&
this.md5 == rhs.md5 &&
this.metadata == rhs.metadata &&
this.name == rhs.name &&
this.uploadDate == rhs.uploadDate);
}
/// <summary>
/// Sets the aliases for an existing GridFS file.
/// </summary>
/// <param name="fileInfo">The GridFS file.</param>
/// <param name="aliases">The aliases.</param>
public void SetAliases(MongoGridFSFileInfo fileInfo, string[] aliases)
{
var database = GetDatabase(ReadPreference.Primary);
var filesCollection = GetFilesCollection(database);
var query = Query.EQ("_id", fileInfo.Id);
var update = (aliases == null) ? Update.Unset("aliases") : Update.Set("aliases", new BsonArray(aliases));
filesCollection.Update(query, update, _settings.WriteConcern);
}
/// <summary>
/// Opens an existing GridFS file for writing.
/// </summary>
/// <param name="remoteFileName">The remote file name.</param>
/// <returns>A stream.</returns>
public MongoGridFSStream OpenWrite(string remoteFileName)
{
var fileInfo = new MongoGridFSFileInfo(this, remoteFileName);
return(fileInfo.OpenWrite());
}
/// <summary>
/// Initializes a new instance of the MongoGridFSStream class.
/// </summary>
/// <param name="fileInfo">The GridFS file info.</param>
/// <param name="mode">The mode.</param>
/// <param name="access">The acess.</param>
public MongoGridFSStream(
MongoGridFSFileInfo fileInfo,
FileMode mode,
FileAccess access
)
{
this.gridFS = fileInfo.GridFS;
this.fileInfo = fileInfo;
this.mode = mode;
this.access = access;
var exists = fileInfo.Exists;
string message;
switch (mode)
{
case FileMode.Append:
if (exists)
{
OpenAppend();
}
else
{
OpenCreate();
}
break;
case FileMode.Create:
if (exists)
{
OpenTruncate();
}
else
{
OpenCreate();
}
break;
case FileMode.CreateNew:
if (exists)
{
message = string.Format("File already exists: {0}", fileInfo.Name);
throw new IOException(message);
}
else
{
OpenCreate();
}
break;
case FileMode.Open:
if (exists)
{
OpenExisting();
}
else
{
message = string.Format("File not found: {0}", fileInfo.Name);
throw new FileNotFoundException(message);
}
break;
case FileMode.OpenOrCreate:
if (exists)
{
OpenExisting();
}
else
{
OpenCreate();
}
break;
case FileMode.Truncate:
if (exists)
{
OpenTruncate();
}
else
{
message = string.Format("File not found: {0}", fileInfo.Name);
throw new FileNotFoundException(message);
}
break;
default:
message = string.Format("Invalid FileMode: {0}", fileInfo.Name);
throw new ArgumentException(message, "mode");
}
gridFS.EnsureIndexes();
}
/// <summary>
/// Opens an existing GridFS file for writing.
/// </summary>
/// <param name="remoteFileName">The remote file name.</param>
/// <param name="createOptions">The create options.</param>
/// <returns>A stream.</returns>
public MongoGridFSStream OpenWrite(
string remoteFileName,
MongoGridFSCreateOptions createOptions
) {
var fileInfo = new MongoGridFSFileInfo(this, remoteFileName, createOptions);
return fileInfo.OpenWrite();
}
/// <summary>
/// Sets the content type for an existing GridFS file.
/// </summary>
/// <param name="fileInfo">The GridFS file.</param>
/// <param name="contentType">The content type.</param>
public void SetContentType(
MongoGridFSFileInfo fileInfo,
string contentType
) {
var query = Query.EQ("_id", fileInfo.Id);
var update = (contentType == null) ? Update.Unset("contentType") : Update.Set("contentType", contentType);
files.Update(query, update);
}
/// <summary>
/// Opens a GridFS file with the specified mode.
/// </summary>
/// <param name="remoteFileName">The remote file name.</param>
/// <param name="mode">The mode.</param>
/// <returns>A stream.</returns>
public MongoGridFSStream Open(
string remoteFileName,
FileMode mode
) {
var fileInfo = new MongoGridFSFileInfo(this, remoteFileName);
return fileInfo.Open(mode);
}
/// <summary>
/// Opens an existing UTF-8 encoded text GridFS file for reading.
/// </summary>
/// <param name="remoteFileName">The remote file name.</param>
/// <returns>A stream reader.</returns>
public StreamReader OpenText(
string remoteFileName
) {
var fileInfo = new MongoGridFSFileInfo(this, remoteFileName);
return fileInfo.OpenText();
}
/// <summary>
/// Appends UTF-8 encoded text to an existing GridFS file.
/// </summary>
/// <param name="remoteFileName">The remote file name.</param>
/// <returns>A StreamWriter.</returns>
public StreamWriter AppendText(
string remoteFileName
) {
var fileInfo = new MongoGridFSFileInfo(this, remoteFileName);
return fileInfo.AppendText();
}
/// <summary>
/// Downloads a GridFS file.
/// </summary>
/// <param name="stream">The destination stream.</param>
/// <param name="fileInfo">The GridFS file.</param>
public void Download(
Stream stream,
MongoGridFSFileInfo fileInfo
) {
using (database.RequestStart(database.Settings.SlaveOk)) {
EnsureIndexes();
string md5Client;
using (var md5Algorithm = MD5.Create()) {
var numberOfChunks = (fileInfo.Length + fileInfo.ChunkSize - 1) / fileInfo.ChunkSize;
for (int n = 0; n < numberOfChunks; n++) {
var query = Query.And(
Query.EQ("files_id", fileInfo.Id),
Query.EQ("n", n)
);
var chunk = chunks.FindOne(query);
if (chunk == null) {
string errorMessage = string.Format("Chunk {0} missing for GridFS file '{1}'.", n, fileInfo.Name);
throw new MongoGridFSException(errorMessage);
}
var data = chunk["data"].AsBsonBinaryData;
if (data.Bytes.Length != fileInfo.ChunkSize) {
// the last chunk only has as many bytes as needed to complete the file
if (n < numberOfChunks - 1 || data.Bytes.Length != fileInfo.Length % fileInfo.ChunkSize) {
string errorMessage = string.Format("Chunk {0} for GridFS file '{1}' is the wrong size.", n, fileInfo.Name);
throw new MongoGridFSException(errorMessage);
}
}
stream.Write(data.Bytes, 0, data.Bytes.Length);
md5Algorithm.TransformBlock(data.Bytes, 0, data.Bytes.Length, null, 0);
}
md5Algorithm.TransformFinalBlock(new byte[0], 0, 0);
md5Client = BsonUtils.ToHexString(md5Algorithm.Hash);
}
if (!md5Client.Equals(fileInfo.MD5, StringComparison.OrdinalIgnoreCase)) {
throw new MongoGridFSException("Download client and server MD5 hashes are not equal.");
}
}
}
/// <summary>
/// Opens an existing GridFS file for writing.
/// </summary>
/// <param name="remoteFileName">The remote file name.</param>
/// <param name="createOptions">The create options.</param>
/// <returns>A stream.</returns>
public MongoGridFSStream OpenWrite(string remoteFileName, MongoGridFSCreateOptions createOptions)
{
using (_server.RequestStart(null, ReadPreference.Primary))
{
var serverInstance = _server.RequestConnection.ServerInstance;
var fileInfo = new MongoGridFSFileInfo(_server, serverInstance, _databaseName, _settings, remoteFileName, createOptions);
return fileInfo.OpenWrite();
}
}
/// <summary>
/// Opens an existing UTF-8 encoded text GridFS file for reading.
/// </summary>
/// <param name="remoteFileName">The remote file name.</param>
/// <returns>A stream reader.</returns>
public StreamReader OpenText(string remoteFileName)
{
using (_server.RequestStart(null, _settings.ReadPreference))
{
var serverInstance = _server.RequestConnection.ServerInstance;
var fileInfo = new MongoGridFSFileInfo(_server, serverInstance, _databaseName, _settings, remoteFileName);
return fileInfo.OpenText();
}
}
/// <summary>
/// Opens a GridFS file with the specified mode, access and create options.
/// </summary>
/// <param name="remoteFileName">The remote file name.</param>
/// <param name="mode">The mode.</param>
/// <param name="access">The access.</param>
/// <param name="createOptions">The create options.</param>
/// <returns>A stream.</returns>
public MongoGridFSStream Open(
string remoteFileName,
FileMode mode,
FileAccess access,
MongoGridFSCreateOptions createOptions)
{
using (_server.RequestStart(null, DetermineReadPreference(mode, access)))
{
var serverInstance = _server.RequestConnection.ServerInstance;
var fileInfo = new MongoGridFSFileInfo(_server, serverInstance, _databaseName, _settings, remoteFileName, createOptions);
return fileInfo.Open(mode, access);
}
}
/// <summary>
/// Downloads a GridFS file.
/// </summary>
/// <param name="stream">The destination stream.</param>
/// <param name="fileInfo">The GridFS file.</param>
public void Download(Stream stream, MongoGridFSFileInfo fileInfo)
{
if (_settings.VerifyMD5 && fileInfo.MD5 == null)
{
throw new MongoGridFSException("VerifyMD5 is true and file being downloaded has no MD5 hash.");
}
using (_server.RequestStart(null, _settings.ReadPreference))
{
var database = GetDatabase();
var chunksCollection = GetChunksCollection(database);
string md5Client = null;
using (var md5Algorithm = _settings.VerifyMD5 ? MD5.Create() : null)
{
var numberOfChunks = (fileInfo.Length + fileInfo.ChunkSize - 1) / fileInfo.ChunkSize;
for (var n = 0L; n < numberOfChunks; n++)
{
var query = Query.And(Query.EQ("files_id", fileInfo.Id), Query.EQ("n", n));
var chunk = chunksCollection.FindOne(query);
if (chunk == null)
{
string errorMessage = string.Format("Chunk {0} missing for GridFS file '{1}'.", n, fileInfo.Name);
throw new MongoGridFSException(errorMessage);
}
var data = chunk["data"].AsBsonBinaryData;
if (data.Bytes.Length != fileInfo.ChunkSize)
{
// the last chunk only has as many bytes as needed to complete the file
if (n < numberOfChunks - 1 || data.Bytes.Length != fileInfo.Length % fileInfo.ChunkSize)
{
string errorMessage = string.Format("Chunk {0} for GridFS file '{1}' is the wrong size.", n, fileInfo.Name);
throw new MongoGridFSException(errorMessage);
}
}
stream.Write(data.Bytes, 0, data.Bytes.Length);
if (_settings.VerifyMD5)
{
md5Algorithm.TransformBlock(data.Bytes, 0, data.Bytes.Length, null, 0);
}
}
if (_settings.VerifyMD5)
{
md5Algorithm.TransformFinalBlock(new byte[0], 0, 0);
md5Client = BsonUtils.ToHexString(md5Algorithm.Hash);
}
}
if (_settings.VerifyMD5 && !md5Client.Equals(fileInfo.MD5, StringComparison.OrdinalIgnoreCase))
{
throw new MongoGridFSException("Download client and server MD5 hashes are not equal.");
}
}
}
/// <summary>
/// Creates or opens a GridFS file for writing UTF-8 encoded text.
/// </summary>
/// <param name="remoteFileName">The remote file name.</param>
/// <returns>A stream writer.</returns>
public StreamWriter CreateText(string remoteFileName)
{
using (_server.RequestStart(null, ReadPreference.Primary))
{
var serverInstance = _server.RequestConnection.ServerInstance;
var fileInfo = new MongoGridFSFileInfo(_server, serverInstance, _databaseName, _settings, remoteFileName);
return fileInfo.CreateText();
}
}
/// <summary>
/// Creates or opens a GridFS file for writing UTF-8 encoded text.
/// </summary>
/// <param name="remoteFileName">The remote file name.</param>
/// <param name="createOptions">The create options.</param>
/// <returns>A stream writer.</returns>
public StreamWriter CreateText(
string remoteFileName,
MongoGridFSCreateOptions createOptions
) {
var fileInfo = new MongoGridFSFileInfo(this, remoteFileName, createOptions);
return fileInfo.CreateText();
}
/// <summary>
/// Sets the content type for an existing GridFS file.
/// </summary>
/// <param name="fileInfo">The GridFS file.</param>
/// <param name="contentType">The content type.</param>
public void SetContentType(MongoGridFSFileInfo fileInfo, string contentType)
{
var database = GetDatabase(ReadPreference.Primary);
var filesCollection = GetFilesCollection(database);
var query = Query.EQ("_id", fileInfo.Id);
var update = (contentType == null) ? Update.Unset("contentType") : Update.Set("contentType", contentType);
filesCollection.Update(query, update, _settings.WriteConcern);
}
/// <summary>
/// Downloads a GridFS file.
/// </summary>
/// <param name="localFileName">The local file name.</param>
/// <param name="fileInfo">The GridFS file.</param>
public void Download(
string localFileName,
MongoGridFSFileInfo fileInfo
) {
using (Stream stream = File.Create(localFileName)) {
Download(stream, fileInfo);
}
}
/// <summary>
/// Sets the metadata for an existing GridFS file.
/// </summary>
/// <param name="fileInfo">The GridFS file.</param>
/// <param name="metadata">The metadata.</param>
public void SetMetadata(MongoGridFSFileInfo fileInfo, BsonValue metadata)
{
var database = GetDatabase(ReadPreference.Primary);
var filesCollection = GetFilesCollection(database);
var query = Query.EQ("_id", fileInfo.Id);
var update = (metadata == null) ? Update.Unset("metadata") : Update.Set("metadata", metadata);
filesCollection.Update(query, update, _settings.WriteConcern);
}
/// <summary>
/// Opens a GridFS file with the specified mode, access and create options.
/// </summary>
/// <param name="remoteFileName">The remote file name.</param>
/// <param name="mode">The mode.</param>
/// <param name="access">The access.</param>
/// <param name="createOptions">The create options.</param>
/// <returns>A stream.</returns>
public MongoGridFSStream Open(
string remoteFileName,
FileMode mode,
FileAccess access,
MongoGridFSCreateOptions createOptions
) {
var fileInfo = new MongoGridFSFileInfo(this, remoteFileName, createOptions);
return fileInfo.Open(mode, access);
}
private bool _updateMD5; // will eventually be removed, for now initialize from settings
// constructors
/// <summary>
/// Initializes a new instance of the MongoGridFSStream class.
/// </summary>
/// <param name="fileInfo">The GridFS file info.</param>
/// <param name="mode">The mode.</param>
public MongoGridFSStream(MongoGridFSFileInfo fileInfo, FileMode mode)
: this(fileInfo, mode, FileAccess.ReadWrite)
{
}
/// <summary>
/// Opens an existing GridFS file for writing.
/// </summary>
/// <param name="remoteFileName">The remote file name.</param>
/// <returns>A stream.</returns>
public MongoGridFSStream OpenWrite(
string remoteFileName
) {
var fileInfo = new MongoGridFSFileInfo(this, remoteFileName);
return fileInfo.OpenWrite();
}
/// <summary>
/// Initializes a new instance of the MongoGridFSStream class.
/// </summary>
/// <param name="fileInfo">The GridFS file info.</param>
/// <param name="mode">The mode.</param>
/// <param name="access">The acess.</param>
public MongoGridFSStream(MongoGridFSFileInfo fileInfo, FileMode mode, FileAccess access)
{
_gridFS = fileInfo.GridFS;
_fileInfo = fileInfo;
_mode = mode;
_access = access;
_updateMD5 = _gridFS.Settings.UpdateMD5;
var exists = fileInfo.Exists;
string message;
switch (mode)
{
case FileMode.Append:
if (exists)
{
OpenAppend();
}
else
{
OpenCreate();
}
break;
case FileMode.Create:
if (exists)
{
OpenTruncate();
}
else
{
OpenCreate();
}
break;
case FileMode.CreateNew:
if (exists)
{
message = string.Format("File '{0}' already exists.", fileInfo.Name);
throw new IOException(message);
}
else
{
OpenCreate();
}
break;
case FileMode.Open:
if (exists)
{
OpenExisting();
}
else
{
message = string.Format("File '{0}' not found.", fileInfo.Name);
throw new FileNotFoundException(message);
}
break;
case FileMode.OpenOrCreate:
if (exists)
{
OpenExisting();
}
else
{
OpenCreate();
}
break;
case FileMode.Truncate:
if (exists)
{
OpenTruncate();
}
else
{
message = string.Format("File '{0}' not found.", fileInfo.Name);
throw new FileNotFoundException(message);
}
break;
default:
message = string.Format("Invalid FileMode {0}.", mode);
throw new ArgumentException(message, "mode");
}
}
/// <summary>
/// Sets the aliases for an existing GridFS file.
/// </summary>
/// <param name="fileInfo">The GridFS file.</param>
/// <param name="aliases">The aliases.</param>
public void SetAliases(
MongoGridFSFileInfo fileInfo,
string[] aliases
) {
var query = Query.EQ("_id", fileInfo.Id);
var update = (aliases == null) ? Update.Unset("aliases") : Update.Set("aliases", BsonArray.Create(aliases));
files.Update(query, update);
}
/// <summary>
/// Opens an existing UTF-8 encoded text GridFS file for reading.
/// </summary>
/// <param name="remoteFileName">The remote file name.</param>
/// <returns>A stream reader.</returns>
public StreamReader OpenText(string remoteFileName)
{
var fileInfo = new MongoGridFSFileInfo(this, remoteFileName);
return(fileInfo.OpenText());
}
/// <summary>
/// Sets the metadata for an existing GridFS file.
/// </summary>
/// <param name="fileInfo">The GridFS file.</param>
/// <param name="metadata">The metadata.</param>
public void SetMetadata(
MongoGridFSFileInfo fileInfo,
BsonValue metadata
) {
var query = Query.EQ("_id", fileInfo.Id);
var update = (metadata == null) ? Update.Unset("metadata") : Update.Set("metadata", metadata);
files.Update(query, update);
}
// public methods
/// <summary>
/// Appends UTF-8 encoded text to an existing GridFS file.
/// </summary>
/// <param name="remoteFileName">The remote file name.</param>
/// <returns>A StreamWriter.</returns>
public StreamWriter AppendText(string remoteFileName)
{
var fileInfo = new MongoGridFSFileInfo(this, remoteFileName);
return(fileInfo.AppendText());
}
/// <summary>
/// Opens an existing GridFS file for writing.
/// </summary>
/// <param name="remoteFileName">The remote file name.</param>
/// <returns>A stream.</returns>
public MongoGridFSStream OpenWrite(string remoteFileName)
{
if (_settings.ReadPreference != ReadPreference.Primary)
{
var gridFS = GetPrimaryGridFSSettings();
return gridFS.OpenWrite(remoteFileName);
}
using (_server.RequestStart(null, ReadPreference.Primary))
{
var serverInstance = _server.RequestConnection.ServerInstance;
var fileInfo = new MongoGridFSFileInfo(_server, serverInstance, _databaseName, _settings, remoteFileName);
return fileInfo.OpenWrite();
}
}
/// <summary>
/// Creates or opens a GridFS file for writing UTF-8 encoded text.
/// </summary>
/// <param name="remoteFileName">The remote file name.</param>
/// <param name="createOptions">The create options.</param>
/// <returns>A stream writer.</returns>
public StreamWriter CreateText(string remoteFileName, MongoGridFSCreateOptions createOptions)
{
if (_settings.ReadPreference != ReadPreference.Primary)
{
var gridFS = GetPrimaryGridFSSettings();
return gridFS.CreateText(remoteFileName, createOptions);
}
using (_server.RequestStart(null, ReadPreference.Primary))
{
var serverInstance = _server.RequestConnection.ServerInstance;
var fileInfo = new MongoGridFSFileInfo(_server, serverInstance, _databaseName, _settings, remoteFileName, createOptions);
return fileInfo.CreateText();
}
}
