public void TestConstructorFreezesSettings()
{
var settings = new MongoGridFSSettings();
Assert.False(settings.IsFrozen);
var gridFS = new MongoGridFS(_server, _database.Name, settings);
Assert.True(gridFS.Settings.IsFrozen);
}
/// <summary>
/// Store a file in the database
/// </summary>
/// <param name="stream">The stream of the files content</param>
/// <param name="fileName">The remote filename</param>
/// <param name="contentType">The file's content type</param>
/// <returns>GridFS File Info</returns>
public MongoGridFSFileInfo Upload(Stream stream, string fileName, string contentType)
{
MongoGridFS fs = new MongoGridFS(this.store);
MongoGridFSCreateOptions options = new MongoGridFSCreateOptions();
options.ContentType = contentType;
return fs.Upload(stream, fileName, options);
}
internal MongoGridFSFileInfo(
MongoGridFS gridFS,
BsonDocument fileInfo
) {
this.gridFS = gridFS;
CacheFileInfo(fileInfo);
}
public MongoGridFSFileInfo(
MongoGridFS gridFS,
string remoteFileName
)
: this(gridFS, remoteFileName, gridFS.Settings.DefaultChunkSize)
{
}
public void TestConstructorFeezesSettings()
{
var settings = new MongoGridFSSettings();
Assert.IsFalse(settings.IsFrozen);
var gridFS = new MongoGridFS(_database, settings);
Assert.IsTrue(gridFS.Settings.IsFrozen);
}
/// <summary>
/// Create a MongoReaderPlugin with an existing MongoDatabase and specific settings for GridFS
/// </summary>
/// <param name="prefix">The virtual folder representing GridFS assets</param>
/// <param name="db">An existing MongoDatabase instance</param>
/// <param name="gridSettings">
/// Settings for the GridFS connection
/// <see href="http://api.mongodb.org/csharp/1.8/html/7a3abd48-0532-8e7f-3c05-6c9812eb06f8.htm" />
/// </param>
public MongoReaderPlugin(string prefix, MongoDatabase db, MongoGridFSSettings gridSettings)
{
_db = db;
_gridSettings = gridSettings;
_grid = _db.GetGridFS(gridSettings);
VirtualFilesystemPrefix = prefix;
}
/// <summary>
/// Construct MongoQueue
/// </summary>
/// <param name="collection">collection</param>
/// <exception cref="ArgumentNullException">collection is null</exception>
public Queue(MongoCollection collection)
{
if (collection == null) throw new ArgumentNullException("collection");
this.collection = collection;
this.gridfs = collection.Database.GetGridFS(MongoGridFSSettings.Defaults);
}
public void ConstructorFeezesSettingsTest() {
var settings = new MongoGridFSSettings();
settings.IsFrozen.Should().Be.False();
var gridFS = new MongoGridFS(Database, settings);
gridFS.Settings.IsFrozen.Should().Be.True();
}
/// <summary>
/// 添加本地文件
/// </summary>
/// <param name="filePath">本地文件路径</param>
/// <param name="remoteFile">服务Id</param>
/// <returns></returns>
public MetaInfo Add(string filePath, string remoteFile)
{
try
{
_logger.DebugFormat("Add File filePath:{0}, remoteId:{1}", filePath, remoteFile);
MongoGridFSCreateOptions option = new MongoGridFSCreateOptions
{
Id = remoteFile,
UploadDate = DateTime.Now,
ContentType = MimeMapper.GetMimeMapping(filePath),
};
using (var stream = new FileStream(filePath, FileMode.Open))
{
MongoGridFS fs = new MongoGridFS(_context.DataBase);
var info = fs.Upload(stream, remoteFile, option);
return new MetaInfo
{
fileName = remoteFile,
MD5 = info.MD5,
MimeType = info.ContentType,
};
}
}
catch (Exception ex)
{
_logger.Error(ex.Message);
_logger.Error(ex.StackTrace);
throw;
}
}
public void TestFixtureSetup() {
server = MongoServer.Create("mongodb://localhost/?safe=true");
database = server["onlinetests"];
gridFS = database.GridFS;
gridFS.Chunks.RemoveAll();
gridFS.Chunks.ResetIndexCache();
gridFS.Files.RemoveAll();
}
public MongoGridFSTests()
{
_server = LegacyTestConfiguration.Server;
_database = LegacyTestConfiguration.Database;
_gridFS = _database.GridFS;
_gridFS.Chunks.RemoveAll();
_gridFS.Files.RemoveAll();
}
public void OneTimeSetUp()
{
_server = LegacyTestConfiguration.Server;
_database = LegacyTestConfiguration.Database;
_gridFS = _database.GridFS;
_gridFS.Chunks.RemoveAll();
_gridFS.Files.RemoveAll();
}
public void TestFixtureSetup()
{
_server = Configuration.TestServer;
_database = Configuration.TestDatabase;
_gridFS = _database.GridFS;
_gridFS.Chunks.RemoveAll();
_gridFS.Files.RemoveAll();
}
protected override void OnTestFixtureSetUp() {
base.OnTestFixtureSetUp();
gridFS = Database.GridFS;
gridFS.Chunks.RemoveAll();
gridFS.Chunks.ResetIndexCache();
gridFS.Files.RemoveAll();
}
/// <summary>
/// Initializes a new instance of the GridFSFileInfo class.
/// </summary>
/// <param name="gridFS">The GridFS file system that contains the GridFS file.</param>
/// <param name="remoteFileName">The remote file name.</param>
/// <param name="chunkSize">The chunk size.</param>
public MongoGridFSFileInfo(
MongoGridFS gridFS,
string remoteFileName,
int chunkSize
) {
this.gridFS = gridFS;
this.chunkSize = chunkSize;
this.name = remoteFileName;
}
/// <summary>
/// Construct MongoQueue
/// </summary>
/// <param name="url">mongo url like mongodb://localhost</param>
/// <param name="db">db name</param>
/// <param name="collection">collection name</param>
/// <exception cref="ArgumentNullException">url, db or collection is null</exception>
public Queue(string url, string db, string collection)
{
if (url == null) throw new ArgumentNullException("url");
if (db == null) throw new ArgumentNullException("db");
if (collection == null) throw new ArgumentNullException("collection");
this.collection = new MongoClient(url).GetServer().GetDatabase(db).GetCollection(collection);
this.gridfs = this.collection.Database.GetGridFS(MongoGridFSSettings.Defaults);
}
private MongoGridFS WithReadPreferencePrimary()
{
var settings = _settings.Clone();
settings.ReadPreference = ReadPreference.Primary;
var gridFS = new MongoGridFS(_server, _databaseName, settings);
return(gridFS);
}
public Driver()
{
string url = ConfigurationManager.AppSettings["mongoUrl"];
string db = ConfigurationManager.AppSettings["mongoDb"];
this.server = MongoServer.Create(url);
this.database = server.GetDatabase(db);
this.gridFS = database.GridFS;
}
public void TestFixtureSetup() {
server = MongoServer.Create("mongodb://localhost/?safe=true");
database = server["onlinetests"];
var settings = new MongoGridFSSettings {
ChunkSize = 16,
SafeMode = SafeMode.True
};
gridFS = database.GetGridFS(settings);
}
public MongoReaderPlugin(NameValueCollection args)
{
VirtualFilesystemPrefix = string.IsNullOrEmpty(args["prefix"]) ? "~/gridfs/" : args["prefix"];
string connectionString = args["connectionString"];
this.db = MongoDatabase.Create(connectionString);
gridSettings = new MongoGridFSSettings();
grid = db.GetGridFS(gridSettings);
}
/// <summary>
/// Initializes a new instance of the GridFSFileInfo class.
/// </summary>
/// <param name="gridFS">The GridFS file system that contains the GridFS file.</param>
/// <param name="remoteFileName">The remote file name.</param>
/// <param name="chunkSize">The chunk size.</param>
public MongoGridFSFileInfo(
MongoGridFS gridFS,
string remoteFileName,
int chunkSize
)
{
this.gridFS = gridFS;
this.chunkSize = chunkSize;
this.name = remoteFileName;
}
public MongoGridFSStreamTests()
{
_database = LegacyTestConfiguration.Database;
var settings = new MongoGridFSSettings
{
ChunkSize = 16,
WriteConcern = WriteConcern.Acknowledged
};
_gridFS = _database.GetGridFS(settings);
}
protected override void OnTestFixtureSetUp() {
base.OnTestFixtureSetUp();
var settings = new MongoGridFSSettings
{
ChunkSize = 16,
SafeMode = SafeMode.True
};
gridFS = Database.GetGridFS(settings);
}
public BookContext()
{
string connectionString = ConfigurationManager.ConnectionStrings["MongoDB"].ConnectionString;
var con = new MongoUrlBuilder(connectionString);
client = new MongoClient(connectionString);
database = client.GetDatabase(con.DatabaseName);
gridFS = new MongoGridFS(new MongoServer(new MongoServerSettings { Server = con.Server }),con.DatabaseName, new MongoGridFSSettings());
}
public MongoGridFSFileInfo(
MongoGridFS gridFS,
string remoteFileName,
int chunkSize
)
{
this.gridFS = gridFS;
this.chunkSize = chunkSize;
this.id = BsonObjectId.GenerateNewId();
this.name = remoteFileName;
}
object IBsonSerializable.Deserialize(
BsonReader bsonReader,
Type nominalType,
IBsonSerializationOptions options
)
{
MongoGridFS gridFS = ((SerializationOptions)options).GridFS;
var fileInfo = BsonDocument.ReadFrom(bsonReader);
return(new MongoGridFSFileInfo(gridFS, fileInfo));
}
public PatientRepository()
{
_server = new MongoServer(new MongoServerSettings { Server = new MongoServerAddress(_DBHOST), SafeMode = SafeMode.True });
//patients
_patients = _server.GetDatabase(_DBNAME).GetCollection<PatientModel>("patients");
_patients.EnsureIndex(IndexKeys.Ascending("_id"), IndexOptions.SetUnique(true));
_gridFS = _server.GetDatabase(_DBNAME).GridFS;
new MongoDB.Web.Providers.MongoDBMembershipProvider();
}
public void TestFixtureSetup()
{
_server = Configuration.TestServer;
_database = Configuration.TestDatabase;
var settings = new MongoGridFSSettings
{
ChunkSize = 16,
SafeMode = SafeMode.True
};
_gridFS = _database.GetGridFS(settings);
}
public void TestFixtureSetup()
{
_server = Configuration.TestServer;
_database = Configuration.TestDatabase;
var settings = new MongoGridFSSettings(_database)
{
ChunkSize = 16,
WriteConcern = WriteConcern.Errors
};
_gridFS = _database.GetGridFS(settings);
}
/// <summary>
/// Initializes a new instance of the GridFSFileInfo class.
/// </summary>
/// <param name="gridFS">The GridFS file system that contains the GridFS file.</param>
/// <param name="remoteFileName">The remote file name.</param>
/// <param name="createOptions">The create options.</param>
public MongoGridFSFileInfo(MongoGridFS gridFS, string remoteFileName, MongoGridFSCreateOptions createOptions)
{
_gridFS = gridFS;
_aliases = createOptions.Aliases;
_chunkSize = (createOptions.ChunkSize == 0) ? gridFS.Settings.ChunkSize : createOptions.ChunkSize;
_contentType = createOptions.ContentType;
_id = createOptions.Id;
_metadata = createOptions.Metadata;
_name = remoteFileName;
_uploadDate = createOptions.UploadDate;
_cached = true; // prevent values from being overwritten by automatic Refresh
}
/// <summary>
/// Initializes a new instance of the GridFSFileInfo class.
/// </summary>
/// <param name="gridFS">The GridFS file system that contains the GridFS file.</param>
/// <param name="remoteFileName">The remote file name.</param>
/// <param name="createOptions">The create options.</param>
public MongoGridFSFileInfo(MongoGridFS gridFS, string remoteFileName, MongoGridFSCreateOptions createOptions)
{
this.gridFS = gridFS;
this.aliases = createOptions.Aliases;
this.chunkSize = createOptions.ChunkSize == 0 ? gridFS.Settings.ChunkSize : createOptions.ChunkSize;
this.contentType = createOptions.ContentType;
this.id = createOptions.Id;
this.metadata = createOptions.Metadata;
this.name = remoteFileName;
this.uploadDate = createOptions.UploadDate;
this.cached = true; // prevent values from being overwritten by automatic Refresh
}
private void OpenAppend()
{
EnsureServerInstanceIsPrimary();
using (_fileInfo.Server.RequestStart(null, _fileInfo.ServerInstance))
{
var gridFS = new MongoGridFS(_fileInfo.Server, _fileInfo.DatabaseName, _fileInfo.GridFSSettings);
gridFS.EnsureIndexes();
_length = _fileInfo.Length;
_position = _fileInfo.Length;
}
}
/// <summary>
/// Copies a GridFS file.
/// </summary>
/// <param name="destFileName">The destination file name.</param>
/// <param name="createOptions">The create options.</param>
/// <returns>The file info of the new GridFS file.</returns>
public MongoGridFSFileInfo CopyTo(string destFileName, MongoGridFSCreateOptions createOptions)
{
EnsureServerInstanceIsPrimary();
using (_server.RequestStart(_serverInstance))
{
// note: we are aware that the data is making a round trip from and back to the server
// but we choose not to use a script to copy the data locally on the server
// because that would lock the database for too long
var gridFS = new MongoGridFS(_server, _databaseName, _settings);
var stream = OpenRead();
return(gridFS.Upload(stream, destFileName, createOptions));
}
}
/// <summary>
/// Create a MongoReaderPlugin from plug-in arguments
/// </summary>
/// <param name="args"></param>
public MongoReaderPlugin(NameValueCollection args)
{
VirtualFilesystemPrefix = string.IsNullOrEmpty(args["prefix"]) ? "~/gridfs/" : args["prefix"];
var mongoUrl = new MongoUrl(args["connectionString"]);
// Using new client, server database initialization. Wordy but recommended.
var mongoClient = new MongoClient(mongoUrl);
var mongoServer = mongoClient.GetServer();
_db = mongoServer.GetDatabase(mongoUrl.DatabaseName);
_gridSettings = new MongoGridFSSettings();
_grid = _db.GetGridFS(_gridSettings);
}
public static MongoGridFSFileInfo UploadImageToDish(this Dish dishWithImages, MongoGridFS gridFS, System.IO.Stream fs, string imageName, string contentType)
{
log.DebugFormat("[UploadImageToDish] This RestaurantBasicData.Id={0}, MongoGridFS, imageName={1}, contentType={2}.", dishWithImages.Id, gridFS.ToString(), imageName, contentType);
MongoGridFSCreateOptions gridFSOption = new MongoGridFSCreateOptions();
gridFSOption.ContentType = contentType;
var gridFsInfo = gridFS.Upload(fs, imageName, gridFSOption);
ImageData convertedValue = ImageServices.ConvertToImageData(gridFsInfo);
dishWithImages.Image = convertedValue;
//dishWithImages.Images[0] = convertedValue;
var fileId = gridFsInfo.Id;
return gridFsInfo;
}
/// <summary>
/// Moves the most recent version of a GridFS file.
/// </summary>
/// <param name="destFileName">The destination file name.</param>
public void MoveTo(string destFileName)
{
EnsureServerInstanceIsPrimary();
using (_server.RequestStart(_serverInstance))
{
var gridFS = new MongoGridFS(_server, _databaseName, _settings);
var database = gridFS.GetDatabase(ReadPreference.Primary);
var filesCollection = gridFS.GetFilesCollection(database);
var query = Query.EQ("_id", _id);
var update = Update.Set("filename", destFileName);
filesCollection.Update(query, update);
}
}
private void OpenTruncate()
{
EnsureServerInstanceIsPrimary();
using (_fileInfo.Server.RequestStart(null, _fileInfo.ServerInstance))
{
var gridFS = new MongoGridFS(_fileInfo.Server, _fileInfo.DatabaseName, _fileInfo.GridFSSettings);
gridFS.EnsureIndexes();
_fileIsDirty = true;
// existing chunks will be overwritten as needed and extra chunks will be removed on Close
_length = 0;
_position = 0;
}
}
// private methods
private void AddMissingChunks()
{
using (_fileInfo.Server.RequestStart(null, _fileInfo.ServerInstance))
{
var gridFS = new MongoGridFS(_fileInfo.Server, _fileInfo.DatabaseName, _fileInfo.GridFSSettings);
var database = gridFS.GetDatabase(ReadPreference.Primary);
var chunksCollection = gridFS.GetChunksCollection(database);
var query = Query.EQ("files_id", _fileInfo.Id);
var fields = Fields.Include("n");
var chunkCount = (_length + _fileInfo.ChunkSize - 1) / _fileInfo.ChunkSize;
var chunksFound = new HashSet <long>();
var foundExtraChunks = false;
foreach (var chunk in chunksCollection.Find(query).SetFields(fields))
{
var n = chunk["n"].ToInt64();
chunksFound.Add(n);
if (n >= chunkCount)
{
foundExtraChunks = true;
}
}
if (foundExtraChunks)
{
var extraChunksQuery = Query.And(Query.EQ("files_id", _fileInfo.Id), Query.GTE("n", chunkCount));
chunksCollection.Remove(extraChunksQuery);
}
BsonBinaryData zeros = null; // delay creating it until it's actually needed
for (var n = 0L; n < chunkCount; n++)
{
if (!chunksFound.Contains(n))
{
if (zeros == null)
{
zeros = new BsonBinaryData(new byte[_fileInfo.ChunkSize]);
}
var missingChunk = new BsonDocument
{
{ "_id", ObjectId.GenerateNewId() },
{ "files_id", _fileInfo.Id },
{ "n", (n < int.MaxValue) ? (BsonValue) new BsonInt32((int)n) : new BsonInt64(n) },
{ "data", zeros }
};
chunksCollection.Insert(missingChunk);
}
}
}
}
// uploading all the chunks into grid.fs.files asynchronously but we have to watch out for
// resource competition. so we will only allow upto 'simultaneousUploads' tasks run at a time.
// this ensure that gridfs to not overwhelm with write requests.
public void multiThreadedUpload(List<byte[]> chunks, string id, MongoGridFS grid)
{
SemaphoreSlim max = new SemaphoreSlim(simultaneousUploads);
var tasks = new Task[chunks.Count];
for (var i = 0; i < chunks.Count; i++) {
max.Wait();
var index = i;
var chunkMetadata = new BsonDocument { { "files_id", new ObjectId(id) }, { "n", i }, { "data", chunks[i] } };
tasks[i] = Task.Factory.StartNew(() => writeToGrid(chunkMetadata, grid, index)
, TaskCreationOptions.LongRunning)
.ContinueWith( (task) => max.Release());
}
Task.WaitAll(tasks);
}
private static MongoServerInstance GetServerInstance(MongoGridFS gridFS)
{
if (gridFS == null)
{
throw new ArgumentNullException("gridFS");
}
// bind to one of the nodes using the ReadPreference
var server = gridFS.Server;
using (server.RequestStart(gridFS.Settings.ReadPreference))
{
return(server.RequestServerInstance);
}
}
public virtual void Setup()
{
collection = new MongoClient(ConfigurationManager.AppSettings["mongoQueueUrl"])
.GetServer()
.GetDatabase(ConfigurationManager.AppSettings["mongoQueueDb"])
.GetCollection(ConfigurationManager.AppSettings["mongoQueueCollection"]);
collection.Drop();
gridfs = collection.Database.GetGridFS(MongoGridFSSettings.Defaults);
gridfs.Files.Drop();
gridfs.Chunks.Drop();
queue = new Queue();
}
private void LoadChunk(long chunkIndex)
{
if (_chunkIsDirty)
{
SaveChunk();
}
using (_fileInfo.Server.RequestStart(null, _fileInfo.ServerInstance))
{
var gridFS = new MongoGridFS(_fileInfo.Server, _fileInfo.DatabaseName, _fileInfo.GridFSSettings);
var database = gridFS.GetDatabase();
var chunksCollection = gridFS.GetChunksCollection(database);
var query = Query.And(Query.EQ("files_id", _fileInfo.Id), Query.EQ("n", chunkIndex));
var document = chunksCollection.FindOne(query);
if (document == null)
{
if (_chunk == null)
{
_chunk = new byte[_fileInfo.ChunkSize];
}
else
{
Array.Clear(_chunk, 0, _chunk.Length);
}
_chunkId = ObjectId.GenerateNewId();
}
else
{
var bytes = document["data"].AsBsonBinaryData.Bytes;
if (bytes.Length == _fileInfo.ChunkSize)
{
_chunk = bytes;
}
else
{
if (_chunk == null)
{
_chunk = new byte[_fileInfo.ChunkSize];
}
Buffer.BlockCopy(bytes, 0, _chunk, 0, bytes.Length);
Array.Clear(_chunk, bytes.Length, _chunk.Length - bytes.Length);
}
_chunkId = document["_id"];
}
_chunkIndex = chunkIndex;
}
}
private void SaveChunk()
{
using (_fileInfo.Server.RequestStart(_fileInfo.ServerInstance))
{
var connectionId = _fileInfo.Server.RequestConnectionId;
var gridFS = new MongoGridFS(_fileInfo.Server, _fileInfo.DatabaseName, _fileInfo.GridFSSettings);
var database = gridFS.GetDatabase(ReadPreference.Primary);
var chunksCollection = gridFS.GetChunksCollection(database);
var lastChunkIndex = (_length + _fileInfo.ChunkSize - 1) / _fileInfo.ChunkSize - 1;
if (_chunkIndex == -1 || _chunkIndex > lastChunkIndex)
{
var message = string.Format("Invalid chunk index {0}.", _chunkIndex);
throw new MongoGridFSException(connectionId, message);
}
var lastChunkSize = (int)(_length % _fileInfo.ChunkSize);
if (lastChunkSize == 0)
{
lastChunkSize = _fileInfo.ChunkSize;
}
BsonBinaryData data;
if (_chunkIndex < lastChunkIndex || lastChunkSize == _fileInfo.ChunkSize)
{
data = new BsonBinaryData(_chunk);
}
else
{
var lastChunk = new byte[lastChunkSize];
Buffer.BlockCopy(_chunk, 0, lastChunk, 0, lastChunkSize);
data = new BsonBinaryData(lastChunk);
}
var query = Query.EQ("_id", _chunkId);
var update = new UpdateDocument
{
{ "_id", _chunkId },
{ "files_id", _fileInfo.Id },
{ "n", _chunkIndex < int.MaxValue ? (BsonValue)(BsonInt32)(int)_chunkIndex : (BsonInt64)_chunkIndex },
{ "data", data }
};
chunksCollection.Update(query, update, UpdateFlags.Upsert);
_chunkIsDirty = false;
}
}
/// <summary>
/// Deletes a GridFS file.
/// </summary>
public void Delete()
{
EnsureServerInstanceIsPrimary();
using (_server.RequestStart(_serverInstance))
{
var gridFS = new MongoGridFS(_server, _databaseName, _settings);
gridFS.EnsureIndexes();
if (Exists)
{
var database = gridFS.GetDatabase(ReadPreference.Primary);
var filesCollection = gridFS.GetFilesCollection(database);
var chunksCollection = gridFS.GetChunksCollection(database);
filesCollection.Remove(Query.EQ("_id", _id), gridFS.Settings.WriteConcern);
chunksCollection.Remove(Query.EQ("files_id", _id), gridFS.Settings.WriteConcern);
}
}
}
private void LoadChunkNoData(long chunkIndex)
{
if (_chunkIsDirty)
{
SaveChunk();
}
using (_fileInfo.Server.RequestStart(null, _fileInfo.ServerInstance))
{
var gridFS = new MongoGridFS(_fileInfo.Server, _fileInfo.DatabaseName, _fileInfo.GridFSSettings);
var database = gridFS.GetDatabase();
var chunksCollection = gridFS.GetChunksCollection(database);
if (_chunk == null)
{
_chunk = new byte[_fileInfo.ChunkSize];
}
else
{
Array.Clear(_chunk, 0, _chunk.Length);
}
var query = Query.And(Query.EQ("files_id", _fileInfo.Id), Query.EQ("n", chunkIndex));
var fields = Fields.Include("_id");
var document = chunksCollection.Find(query).SetFields(fields).SetLimit(1).FirstOrDefault();
if (document == null)
{
_chunkId = ObjectId.GenerateNewId();
}
else
{
_chunkId = document["_id"];
}
_chunkIndex = chunkIndex;
}
}
private void OpenCreate()
{
EnsureServerInstanceIsPrimary();
using (_fileInfo.Server.RequestStart(null, _fileInfo.ServerInstance))
{
var gridFS = new MongoGridFS(_fileInfo.Server, _fileInfo.DatabaseName, _fileInfo.GridFSSettings);
var database = gridFS.GetDatabase(ReadPreference.Primary);
var filesCollection = gridFS.GetFilesCollection(database);
gridFS.EnsureIndexes();
_fileIsDirty = true;
if (_fileInfo.Id == null)
{
_fileInfo.SetId(ObjectId.GenerateNewId());
}
var aliases = (_fileInfo.Aliases != null) ? new BsonArray(_fileInfo.Aliases) : null;
var file = new BsonDocument
{
{ "_id", _fileInfo.Id },
{ "filename", _fileInfo.Name, !string.IsNullOrEmpty(_fileInfo.Name) },
{ "length", 0 },
{ "chunkSize", _fileInfo.ChunkSize },
{ "uploadDate", _fileInfo.UploadDate },
{ "md5", BsonNull.Value }, // will be updated when the file is closed (unless UpdateMD5 is false)
{ "contentType", _fileInfo.ContentType, !string.IsNullOrEmpty(_fileInfo.ContentType) }, // optional
{ "aliases", aliases, aliases != null }, // optional
{ "metadata", _fileInfo.Metadata, _fileInfo.Metadata != null } // optional
};
filesCollection.Insert(file);
_length = 0;
_position = 0;
}
}
/// <summary>
/// Initializes a new instance of the GridFSFileInfo class.
/// </summary>
/// <param name="gridFS">The GridFS file system that contains the GridFS file.</param>
/// <param name="remoteFileName">The remote file name.</param>
public MongoGridFSFileInfo(MongoGridFS gridFS, string remoteFileName)
: this(gridFS, remoteFileName, gridFS.Settings.ChunkSize)
{
}
internal MongoGridFSFileInfo(MongoGridFS gridFS, BsonDocument fileInfo)
{
this.gridFS = gridFS;
CacheFileInfo(fileInfo);
}
public MongoGridFSFileInfo(MongoGridFS gridFS, string remoteFileName, int chunkSize)
: this(GetServer(gridFS), GetServerInstance(gridFS), GetDatabaseName(gridFS), GetGridFSSettings(gridFS), remoteFileName)
{
_chunkSize = chunkSize;
}
/// <summary>
/// Initializes a new instance of the GridFSFileInfo class.
/// </summary>
/// <param name="gridFS">The GridFS file system that contains the GridFS file.</param>
/// <param name="remoteFileName">The remote file name.</param>
/// <param name="chunkSize">The chunk size.</param>
public MongoGridFSFileInfo(MongoGridFS gridFS, string remoteFileName, int chunkSize)
{
_gridFS = gridFS;
_chunkSize = chunkSize;
_name = remoteFileName;
}
/// <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");
}
}
public MongoGridFSFileInfo(MongoGridFS gridFS, string remoteFileName, MongoGridFSCreateOptions createOptions)
: this(GetServer(gridFS), GetServerInstance(gridFS), GetDatabaseName(gridFS), GetGridFSSettings(gridFS), remoteFileName, createOptions)
{
}
/// <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();
}