private static bool HasCollectionCreationOptions(FlexibleOptions options)
{
return((options.HasOption("collection-wt-block-compressor") && valid_wt_compressors.Contains(options.Get("collection-wt-block-compressor", "invalid"))) ||
(!String.IsNullOrEmpty(options.Get("collection-wt-allocation"))));
}
private static void CreateCollection(MongoCollection <BsonDocument> sourceCollection, MongoCollection <BsonDocument> targetCollection, FlexibleOptions options)
{
if (targetCollection.Exists())
{
return;
}
List <string> config = new List <string> ();
if (!String.IsNullOrWhiteSpace(options.Get("collection-wt-configString")))
{
config.AddRange(options.Get("collection-wt-configString", "").Split(',').Select(i => i.Trim()).Where(i => !String.IsNullOrEmpty(i)));
}
if (options.HasOption("collection-wt-block-compressor") && valid_wt_compressors.Contains(options.Get("collection-wt-block-compressor", "invalid")))
{
config.RemoveAll(i => i.StartsWith("block_compressor=", StringComparison.OrdinalIgnoreCase));
config.Add("block_compressor=" + options.Get("collection-wt-block-compressor", "").ToLowerInvariant());
}
if (!String.IsNullOrWhiteSpace(options.Get("collection-wt-allocation")))
{
// Mongodb version 3.0.4 defaults to: "allocation_size=4KB,internal_page_max=4KB,leaf_page_max=32KB,leaf_value_max=1MB"
if (options.Get("collection-wt-allocation") == "2x")
{
config.RemoveAll(i =>
i.StartsWith("allocation_size=", StringComparison.OrdinalIgnoreCase) ||
i.StartsWith("leaf_page_max=", StringComparison.OrdinalIgnoreCase) ||
i.StartsWith("internal_page_max=", StringComparison.OrdinalIgnoreCase));
config.Add("allocation_size=8KB");
config.Add("leaf_page_max=64KB");
config.Add("internal_page_max=8KB");
}
else if (options.Get("collection-wt-allocation") == "4x")
{
config.RemoveAll(i =>
i.StartsWith("allocation_size=", StringComparison.OrdinalIgnoreCase) ||
i.StartsWith("leaf_page_max=", StringComparison.OrdinalIgnoreCase) ||
i.StartsWith("internal_page_max=", StringComparison.OrdinalIgnoreCase));
config.Add("allocation_size=16KB");
config.Add("leaf_page_max=64KB");
config.Add("internal_page_max=16KB");
}
else if (options.Get("collection-wt-allocation") == "8x")
{
config.RemoveAll(i =>
i.StartsWith("allocation_size=", StringComparison.OrdinalIgnoreCase) ||
i.StartsWith("leaf_page_max=", StringComparison.OrdinalIgnoreCase) ||
i.StartsWith("internal_page_max=", StringComparison.OrdinalIgnoreCase));
config.Add("allocation_size=32KB");
config.Add("leaf_page_max=128KB");
config.Add("internal_page_max=32KB");
}
}
// apply configuration
if (config.Count > 0)
{
try
{
var storageEngineDoc = new BsonDocument("wiredTiger", new BsonDocument("configString", String.Join(",", config)));
targetCollection.Database.CreateCollection(targetCollection.Name, CollectionOptions.SetStorageEngineOptions(storageEngineDoc));
}
catch (Exception ex)
{
NLog.LogManager.GetLogger("CreateCollection").Error(ex);
}
}
}
/// <summary>
/// Log initialization.
/// </summary>
internal static void InitializeLog (string logFileName = null, string logLevel = null, InitializationOptions initOptions = null, FlexibleOptions appOptions = null)
{
// default parameters initialization from config file
if (String.IsNullOrEmpty (logFileName))
logFileName = _logFileName ?? System.Configuration.ConfigurationManager.AppSettings["logFilename"];
if (String.IsNullOrEmpty (logFileName))
logFileName = ("${basedir}/log/" + typeof (ConsoleUtils).Namespace.Replace (".SimpleHelpers", "") + ".log");
if (String.IsNullOrEmpty (logLevel))
logLevel = _logLevel ?? (System.Configuration.ConfigurationManager.AppSettings["logLevel"] ?? "Info");
// check if log was initialized with same options
if (_logFileName == logFileName && _logLevel == logLevel)
return;
// try to parse loglevel
LogLevel currentLogLevel;
try { currentLogLevel = LogLevel.FromString (logLevel); }
catch { currentLogLevel = LogLevel.Info; }
// save current log configuration
_logFileName = logFileName;
_logLevel = currentLogLevel.ToString ();
// check initialization options
var localOptions = initOptions != null ? initOptions.Clone () : new InitializationOptions ();
// adjust options based on arguments
if (appOptions != null)
{
if (!localOptions.DisableLogFile.HasValue && appOptions.HasOption ("DisableLogFile"))
localOptions.DisableLogFile = appOptions.Get ("DisableLogFile", false);
if (localOptions.EnableLogTargets == null && !String.IsNullOrEmpty (appOptions.Get ("EnableLogTargets")))
localOptions.EnableLogTargets = appOptions.GetAsList ("EnableLogTargets").Where (i => !String.IsNullOrWhiteSpace (i)).Select (i => i.Trim ()).ToArray ();
if (localOptions.DisableLogTargets == null && !String.IsNullOrEmpty (appOptions.Get ("DisableLogTargets")))
localOptions.DisableLogTargets = appOptions.GetAsList ("DisableLogTargets").Where (i => !String.IsNullOrWhiteSpace (i)).Select (i => i.Trim ()).ToArray ();
}
// prepare list of enabled targets
HashSet<string> enabledTargets;
// if enabled log targets was provided, use it!
if (localOptions.EnableLogTargets != null && localOptions.EnableLogTargets.Count > 0)
{
enabledTargets = new HashSet<string> (localOptions.EnableLogTargets, StringComparer.OrdinalIgnoreCase);
}
// else we remove disabled target...
else
{
enabledTargets = new HashSet<string> (StringComparer.OrdinalIgnoreCase) { "console", "file" };
// set enabled targets
if (localOptions.Targets != null)
{
foreach (var i in localOptions.Targets)
{
foreach (var n in GetNLogTargetName (i))
enabledTargets.Add (n);
}
}
// remove disabled targets
if (localOptions.DisableLogTargets != null)
foreach (var i in localOptions.DisableLogTargets)
enabledTargets.Remove (i);
if (localOptions.DisableLogFile ?? false)
enabledTargets.Remove ("file");
}
// prepare log configuration
var config = new NLog.Config.LoggingConfiguration ();
// console output
if (!Console.IsOutputRedirected && enabledTargets.Contains ("console"))
{
var consoleTarget = new NLog.Targets.ColoredConsoleTarget ();
consoleTarget.Layout = "${longdate}\t${callsite}\t${level}\t${message}\t${onexception: \\:[Exception] ${exception:format=tostring}}";
config.AddTarget ("console", consoleTarget);
var rule1 = new NLog.Config.LoggingRule ("*", LogLevel.Trace, consoleTarget);
config.LoggingRules.Add (rule1);
}
// file output
if (enabledTargets.Contains ("file"))
{
var fileTarget = new NLog.Targets.FileTarget ();
fileTarget.FileName = logFileName;
fileTarget.Layout = "${longdate}\t${callsite}\t${level}\t\"${message}${onexception: \t [Exception] ${exception:format=tostring}}\"";
fileTarget.ConcurrentWrites = true;
fileTarget.ConcurrentWriteAttemptDelay = 10;
fileTarget.ConcurrentWriteAttempts = 8;
fileTarget.AutoFlush = true;
fileTarget.KeepFileOpen = true;
fileTarget.DeleteOldFileOnStartup = false;
fileTarget.ArchiveAboveSize = (localOptions.MaxLogFileSize > 0) ? localOptions.MaxLogFileSize : 4 * 1024 * 1024; // 4 Mb
fileTarget.MaxArchiveFiles = (localOptions.MaxArchiveLogFiles > 0) ? localOptions.MaxArchiveLogFiles : 10;
fileTarget.ArchiveNumbering = NLog.Targets.ArchiveNumberingMode.DateAndSequence;
fileTarget.ArchiveDateFormat = "yyyyMMdd";
fileTarget.ArchiveFileName = System.IO.Path.ChangeExtension (logFileName, ".{#}" + System.IO.Path.GetExtension (logFileName));
// set file output to be async (commented out since doesn't work well on mono)
// var wrapper = new NLog.Targets.Wrappers.AsyncTargetWrapper (fileTarget);
config.AddTarget ("file", fileTarget);
// configure log from configuration file
var rule2 = new NLog.Config.LoggingRule ("*", currentLogLevel, fileTarget);
config.LoggingRules.Add (rule2);
}
// External Log Target
if (localOptions.Targets != null)
{
foreach (var t in localOptions.Targets)
{
if (GetNLogTargetName (t).Any (i => enabledTargets.Contains (i)))
{
config.AddTarget (t);
config.LoggingRules.Add (new NLog.Config.LoggingRule ("*", currentLogLevel, t));
}
}
}
// set configuration options
LogManager.Configuration = config;
}