public static void TestChattelWriter_PutAssetSync_FullWriteCache_BadServer_AggregateException()
{
var server = Substitute.For <IAssetServer>();
var config = new ChattelConfiguration(LOCAL_STORAGE_DIR_INFO.FullName, WRITE_CACHE_FILE_INFO.FullName, 4, server);
var localStorage = Substitute.For <IChattelLocalStorage>();
var writer = new ChattelWriter(config, localStorage);
server
.WhenForAnyArgs(x => x.StoreAssetSync(Arg.Any <StratusAsset>()))
.Do(x => {
throw new Exception(); // Just needs an error to cause remote storage failure.
})
;
var testAsset = new StratusAsset {
Id = Guid.NewGuid(),
};
try {
writer.PutAssetSync(testAsset);
}
catch (AggregateException) {
// moving right along.
}
try {
writer.PutAssetSync(testAsset);
}
catch (AggregateException) {
// moving right along.
}
// Write cache currenlty requires one left empty.
Assert.Throws <AggregateException>(() => writer.PutAssetSync(testAsset));
}
public static void BeforeEveryTest()
{
#pragma warning disable RECS0022 // A catch clause that catches System.Exception and has an empty body
try {
Directory.Delete(TestAssetLocalStorageLmdbPartitionedLRUCtor.DATABASE_FOLDER_PATH, true);
}
catch {
}
#pragma warning restore RECS0022 // A catch clause that catches System.Exception and has an empty body
Directory.CreateDirectory(TestAssetLocalStorageLmdbPartitionedLRUCtor.DATABASE_FOLDER_PATH);
var chattelConfigRead = new ChattelConfiguration(TestAssetLocalStorageLmdbPartitionedLRUCtor.DATABASE_FOLDER_PATH);
var chattelConfigWrite = new ChattelConfiguration(TestAssetLocalStorageLmdbPartitionedLRUCtor.DATABASE_FOLDER_PATH);
_readerLocalStorage = new AssetLocalStorageLmdbPartitionedLRU(
chattelConfigRead,
TestAssetLocalStorageLmdbPartitionedLRUCtor.DATABASE_MAX_SIZE_BYTES,
TestAssetLocalStorageLmdbPartitionedLRUCtor.DATABASE_PARTITION_INTERVAL
);
_chattelReader = new ChattelReader(chattelConfigRead, _readerLocalStorage);
_chattelWriter = new ChattelWriter(chattelConfigWrite, _readerLocalStorage);
_storageManager = new StorageManager(
_readerLocalStorage,
TimeSpan.FromMinutes(2),
_chattelReader,
_chattelWriter
);
}
public static void TestChattelWriter_PutAssetSync_WritesBackupRemoteParallel_WithLocalStorage()
{
var server1 = Substitute.For <IAssetServer>();
var server2 = Substitute.For <IAssetServer>();
var config = new ChattelConfiguration(LOCAL_STORAGE_DIR_INFO.FullName, new List <List <IAssetServer> > {
new List <IAssetServer> {
server1,
},
new List <IAssetServer> {
server2,
},
});
var localStorage = Substitute.For <IChattelLocalStorage>();
var writer = new ChattelWriter(config, localStorage);
var testAsset = new StratusAsset {
Id = Guid.NewGuid(),
};
server1.WhenForAnyArgs(x => x.StoreAssetSync(testAsset)).Do(x => throw new AssetWriteException(testAsset.Id));
writer.PutAssetSync(testAsset);
server2.Received(1).StoreAssetSync(testAsset);
}
public static void TestChattelWriter_PutAssetSync_ServerError_AggregateException_ContainsCorrectException()
{
var server = Substitute.For <IAssetServer>();
var config = new ChattelConfiguration(LOCAL_STORAGE_DIR_INFO.FullName, WRITE_CACHE_FILE_INFO.FullName, 4, server);
var localStorage = Substitute.For <IChattelLocalStorage>();
var writer = new ChattelWriter(config, localStorage);
server
.WhenForAnyArgs(x => x.StoreAssetSync(Arg.Any <StratusAsset>()))
.Do(x => {
throw new DriveNotFoundException(); // Just needs an error to cause remote storage failure.
})
;
var testAsset = new StratusAsset {
Id = Guid.NewGuid(),
};
try {
writer.PutAssetSync(testAsset);
}
catch (AggregateException e) {
Assert.IsInstanceOf(typeof(DriveNotFoundException), e.InnerException);
return;
}
Assert.Fail();
}
public static void TestChattelWriter_PutAssetSync_MultipleParallel_AllReceived()
{
var server = Substitute.For <IAssetServer>();
var config = new ChattelConfiguration(server);
var localStorage = Substitute.For <IChattelLocalStorage>();
var writer = new ChattelWriter(config, localStorage);
var testAsset1 = new StratusAsset {
Id = Guid.NewGuid(),
};
var testAsset2 = new StratusAsset {
Id = Guid.NewGuid(),
};
var testAsset3 = new StratusAsset {
Id = Guid.NewGuid(),
};
Parallel.Invoke(
() => writer.PutAssetSync(testAsset1),
() => writer.PutAssetSync(testAsset2),
() => writer.PutAssetSync(testAsset3)
);
server.Received(1).StoreAssetSync(testAsset1);
server.Received(1).StoreAssetSync(testAsset2);
server.Received(1).StoreAssetSync(testAsset3);
}
public static void TestStorageManager_StoreAsset_CallsServerPutAsset()
{
LOG.Info($"Executing {nameof(TestStorageManager_StoreAsset_CallsServerPutAsset)}");
var server = Substitute.For <IAssetServer>();
var config = new ChattelConfiguration(TestAssetLocalStorageLmdbPartitionedLRUCtor.DATABASE_FOLDER_PATH, server);
using (var readerLocalStorage = new AssetLocalStorageLmdbPartitionedLRU(
config,
uint.MaxValue,
TestAssetLocalStorageLmdbPartitionedLRUCtor.DATABASE_PARTITION_INTERVAL
)) {
var reader = new ChattelReader(config, readerLocalStorage);
var writer = new ChattelWriter(config, readerLocalStorage);
var mgr = new StorageManager(
readerLocalStorage,
TimeSpan.FromMinutes(2),
reader,
writer
);
var asset = new StratusAsset {
Id = Guid.NewGuid(),
};
var wait = new AutoResetEvent(false);
mgr.StoreAsset(asset, result => wait.Set());
wait.WaitOne();
server.Received(1).StoreAssetSync(asset);
}
}
public static void TestChattelWriter_PutAssetSync_WritesRemoteSeries_CorrectOrder()
{
var server1 = Substitute.For <IAssetServer>();
var server2 = Substitute.For <IAssetServer>();
var config = new ChattelConfiguration(new List <List <IAssetServer> > {
new List <IAssetServer> {
server1,
},
new List <IAssetServer> {
server2,
},
});
var writer = new ChattelWriter(config);
var testAsset = new StratusAsset {
Id = Guid.NewGuid(),
};
server1.WhenForAnyArgs(x => x.StoreAssetSync(testAsset)).Do(x => throw new AssetWriteException(testAsset.Id));
writer.PutAssetSync(testAsset);
Received.InOrder(() => {
server1.StoreAssetSync(testAsset);
server2.StoreAssetSync(testAsset);
});
}
public static void TestStorageManager_GetAsset_DoubleNoExist_CallsServerRequestOnlyOnce()
{
LOG.Info($"Executing {nameof(TestStorageManager_GetAsset_DoubleNoExist_CallsServerRequestOnlyOnce)}");
// Tests the existence of a negative cache.
var server = Substitute.For <IAssetServer>();
var config = new ChattelConfiguration(TestAssetLocalStorageLmdbPartitionedLRUCtor.DATABASE_FOLDER_PATH, WRITE_CACHE_FILE_PATH, WRITE_CACHE_MAX_RECORD_COUNT, server);
using (var localStorage = new AssetLocalStorageLmdbPartitionedLRU(
config,
TestAssetLocalStorageLmdbPartitionedLRUCtor.DATABASE_MAX_SIZE_BYTES,
TestAssetLocalStorageLmdbPartitionedLRUCtor.DATABASE_PARTITION_INTERVAL
)) {
var reader = new ChattelReader(config, localStorage, false);
var writer = new ChattelWriter(config, localStorage, false);
var assetId = Guid.NewGuid();
var mgr = new StorageManager(
localStorage,
TimeSpan.FromMinutes(2),
reader,
writer
);
mgr.GetAsset(assetId, result => { }, () => { });
mgr.GetAsset(assetId, result => { }, () => { });
server.Received(1).RequestAssetSync(assetId);
}
}
public static void TestWriteCache_Ctor_ExistingFile_MockWriter_MockLocalStorage_CallsLocalStorageGet()
{
var firstId = Guid.NewGuid();
var lastId = Guid.NewGuid();
var records = new Tuple <Guid, bool>[] {
new Tuple <Guid, bool>(firstId, false),
new Tuple <Guid, bool>(Guid.Empty, true),
new Tuple <Guid, bool>(lastId, true),
};
CreateWriteCache(WRITE_CACHE_FILE_INFO, records);
var localStorage = Substitute.For <IChattelLocalStorage>();
var server = Substitute.For <IAssetServer>();
var writer = new ChattelWriter(new ChattelConfiguration(server), localStorage, false);
localStorage.TryGetAsset(firstId, out var asset1).Returns(false);
new WriteCache(
WRITE_CACHE_FILE_INFO,
(uint)records.Length,
writer,
localStorage
);
localStorage.Received().TryGetAsset(firstId, out var assetJunk1);
localStorage.DidNotReceive().TryGetAsset(Guid.Empty, out var assetJunk2);
localStorage.DidNotReceive().TryGetAsset(lastId, out var assetJunk3);
}
public static void TestChattelWriter_PutAssetSync_FullWriteCache_HitsRemote()
{
var server = Substitute.For <IAssetServer>();
var config = new ChattelConfiguration(LOCAL_STORAGE_DIR_INFO.FullName, WRITE_CACHE_FILE_INFO.FullName, 4, server);
var localStorage = Substitute.For <IChattelLocalStorage>();
var writer = new ChattelWriter(config, localStorage);
var testAsset = new StratusAsset {
Id = Guid.NewGuid(),
};
try {
writer.PutAssetSync(testAsset);
}
catch (AggregateException) {
// moving right along.
}
try {
writer.PutAssetSync(testAsset);
}
catch (AggregateException) {
// moving right along.
}
try {
writer.PutAssetSync(testAsset);
}
catch (WriteCacheFullException) {
// moving right along.
}
// Write cache currently requires one left empty.
server.Received(3).StoreAssetSync(testAsset);
}
public static void TestWriteCache_Ctor_ExistingFile_MockWriter_MockLocalStorage_ClearsWriteCache()
{
var firstId = Guid.NewGuid();
var lastId = Guid.NewGuid();
var records = new Tuple <Guid, bool>[] {
new Tuple <Guid, bool>(firstId, false),
new Tuple <Guid, bool>(Guid.Empty, true),
new Tuple <Guid, bool>(lastId, true),
};
CreateWriteCache(WRITE_CACHE_FILE_INFO, records);
var localStorage = Substitute.For <IChattelLocalStorage>();
var server = Substitute.For <IAssetServer>();
var writer = new ChattelWriter(new ChattelConfiguration(new List <List <IAssetServer> > {
new List <IAssetServer> {
server
}
}), localStorage, false);
var firstAsset = new StratusAsset {
Id = firstId,
};
var lastAsset = new StratusAsset {
Id = lastId,
};
localStorage.TryGetAsset(firstId, out var asset1).Returns(parms => { parms[1] = firstAsset; return(true); });
localStorage.TryGetAsset(lastId, out var asset2).Returns(parms => { parms[1] = lastAsset; return(true); });
localStorage.StoreAsset(firstAsset);
localStorage.StoreAsset(lastAsset);
new WriteCache(
WRITE_CACHE_FILE_INFO,
(uint)records.Length,
writer,
localStorage
);
using (var fs = new FileStream(WRITE_CACHE_FILE_INFO.FullName, FileMode.Open, FileAccess.Read)) {
try {
// Skip the header
fs.Seek(WRITE_CACHE_MAGIC_NUMBER.Length, SeekOrigin.Begin);
// Check each row.
for (var recordIndex = 0; recordIndex < WRITE_CACHE_MAX_RECORD_COUNT; ++recordIndex)
{
var buffer = new byte[WriteCacheNode.BYTE_SIZE];
fs.Read(buffer, 0, buffer.Length);
Assert.AreEqual(0, buffer[0], $"Record #{recordIndex + 1} is not marked as available!");
}
}
finally {
fs.Close();
}
}
}
public static void TestChattelWriter_PutAssetSync_Null_ArgumentNullException()
{
var config = new ChattelConfiguration(LOCAL_STORAGE_DIR_INFO.FullName);
var writer = new ChattelWriter(config);
Assert.Throws <ArgumentNullException>(() => writer.PutAssetSync(null));
}
public static void TestChattelWriter_HasUpstream_None_False()
{
var config = new ChattelConfiguration(LOCAL_STORAGE_DIR_INFO.FullName);
var writer = new ChattelWriter(config);
Assert.False(writer.HasUpstream);
}
public static void TestChattelWriter_HasUpstream_Mocked_True()
{
var server = Substitute.For <IAssetServer>();
var config = new ChattelConfiguration(server);
var writer = new ChattelWriter(config);
Assert.True(writer.HasUpstream);
}
public static void TestChattelWriter_PutAssetSync_EmptyId_ArgumentException()
{
var config = new ChattelConfiguration(LOCAL_STORAGE_DIR_INFO.FullName);
var writer = new ChattelWriter(config);
Assert.Throws <ArgumentException>(() => writer.PutAssetSync(new StratusAsset {
Id = Guid.Empty,
}));
}
public static void CleanupAfterEveryTest()
{
LOG.Info($"Executing {nameof(CleanupAfterEveryTest)}");
_chattelReader = null;
_chattelWriter = null;
IDisposable localStorageDisposal = _readerLocalStorage;
_readerLocalStorage = null;
localStorageDisposal.Dispose();
TestAssetLocalStorageLmdbPartitionedLRUCtor.CleanLocalStorageFolder(TestAssetLocalStorageLmdbPartitionedLRUCtor.DATABASE_FOLDER_PATH, WRITE_CACHE_FILE_PATH);
}
public static void BeforeEveryTest()
{
LOG.Info($"Executing {nameof(BeforeEveryTest)}");
TestAssetLocalStorageLmdbPartitionedLRUCtor.RebuildLocalStorageFolder(TestAssetLocalStorageLmdbPartitionedLRUCtor.DATABASE_FOLDER_PATH, WRITE_CACHE_FILE_PATH);
_readerLocalStorage = new AssetLocalStorageLmdbPartitionedLRU(
_chattelConfigRead,
TestAssetLocalStorageLmdbPartitionedLRUCtor.DATABASE_MAX_SIZE_BYTES,
TestAssetLocalStorageLmdbPartitionedLRUCtor.DATABASE_PARTITION_INTERVAL
);
_chattelReader = new ChattelReader(_chattelConfigRead, _readerLocalStorage);
_chattelWriter = new ChattelWriter(_chattelConfigWrite, _readerLocalStorage);
}
public static void TestChattelWriter_PutAssetSync_WritesLocalStorage_NoRemote()
{
var config = new ChattelConfiguration(LOCAL_STORAGE_DIR_INFO.FullName);
var localStorage = Substitute.For <IChattelLocalStorage>();
var writer = new ChattelWriter(config, localStorage);
var testAsset = new StratusAsset {
Id = Guid.NewGuid(),
};
writer.PutAssetSync(testAsset);
localStorage.Received(1).StoreAsset(testAsset);
}
public static void TestChattelWriter_PutAssetSync_WritesRemote_NoLocalStorage()
{
var server = Substitute.For <IAssetServer>();
var config = new ChattelConfiguration(server);
var localStorage = Substitute.For <IChattelLocalStorage>();
var writer = new ChattelWriter(config, localStorage);
var testAsset = new StratusAsset {
Id = Guid.NewGuid(),
};
writer.PutAssetSync(testAsset);
server.Received(1).StoreAssetSync(testAsset);
}
public static void TestChattelWriter_PutAssetSync_Duplicates_AssetExistsException()
{
var config = new ChattelConfiguration(LOCAL_STORAGE_DIR_INFO.FullName);
var localStorage = Substitute.For <IChattelLocalStorage>();
var writer = new ChattelWriter(config, localStorage);
var testAsset = new StratusAsset {
Id = Guid.NewGuid(),
};
localStorage.TryGetAsset(testAsset.Id, out var junk).Returns(x => {
x[1] = testAsset;
return(true);
});
Assert.Throws <AssetExistsException>(() => writer.PutAssetSync(testAsset));
}
public static void TestChattelWriter_PutAssetSync_WritesLocalBeforeRemote()
{
var server = Substitute.For <IAssetServer>();
var config = new ChattelConfiguration(LOCAL_STORAGE_DIR_INFO.FullName, WRITE_CACHE_FILE_INFO.FullName, 4, server);
var localStorage = Substitute.For <IChattelLocalStorage>();
var writer = new ChattelWriter(config, localStorage);
var testAsset = new StratusAsset {
Id = Guid.NewGuid(),
};
writer.PutAssetSync(testAsset);
Received.InOrder(() => {
localStorage.StoreAsset(testAsset);
server.StoreAssetSync(testAsset);
});
}
public static void TestWriteCache_Ctor_ExistingFile_MockWriter_NullCache_ChattelConfigurationException()
{
var records = new Tuple <Guid, bool>[] {
new Tuple <Guid, bool>(Guid.NewGuid(), false),
new Tuple <Guid, bool>(Guid.NewGuid(), false),
};
CreateWriteCache(WRITE_CACHE_FILE_INFO, records);
var localStorage = Substitute.For <IChattelLocalStorage>();
var server = Substitute.For <IAssetServer>();
var writer = new ChattelWriter(new ChattelConfiguration(server), localStorage, false);
Assert.Throws <ChattelConfigurationException>(() => new WriteCache(
WRITE_CACHE_FILE_INFO,
(uint)records.Length,
writer,
null
));
}
public static void TestChattelWriter_PutAssetSync_ServerError_AggregateException()
{
var server = Substitute.For <IAssetServer>();
var config = new ChattelConfiguration(LOCAL_STORAGE_DIR_INFO.FullName, WRITE_CACHE_FILE_INFO.FullName, 4, server);
var localStorage = Substitute.For <IChattelLocalStorage>();
var writer = new ChattelWriter(config, localStorage);
server
.WhenForAnyArgs(x => x.StoreAssetSync(Arg.Any <StratusAsset>()))
.Do(x => {
throw new Exception(); // Just needs an error to cause remote storage failure.
})
;
var testAsset = new StratusAsset {
Id = Guid.NewGuid(),
};
Assert.Throws <AggregateException>(() => writer.PutAssetSync(testAsset));
}
/// <summary>
/// Initializes a new instance of the <see cref="T:LibWhipLru.Cache.StorageManager"/> class.
/// A zero or negative value for the negativeCacheItemLifetime results in the negative cache being disabled.
/// </summary>
/// <param name="localStorage">Local storage for assets.</param>
/// <param name="negativeCacheItemLifetime">Negative cache item lifetime.</param>
/// <param name="reader">Reader.</param>
/// <param name="writer">Writer.</param>
public StorageManager(
AssetLocalStorageLmdbPartitionedLRU localStorage,
TimeSpan negativeCacheItemLifetime,
ChattelReader reader,
ChattelWriter writer
)
{
_localStorage = localStorage ?? throw new ArgumentNullException(nameof(localStorage));
_assetReader = reader ?? throw new ArgumentNullException(nameof(reader));
_assetWriter = writer ?? throw new ArgumentNullException(nameof(writer));
if (negativeCacheItemLifetime.TotalSeconds > 0)
{
_negativeCache = System.Runtime.Caching.MemoryCache.Default;
_negativeCacheLock = new ReaderWriterLockSlim();
_negativeCachePolicy = new System.Runtime.Caching.CacheItemPolicy {
SlidingExpiration = negativeCacheItemLifetime,
};
}
}
public static void TestWriteCache_Ctor_ExistingFile_MockWriter_MockLocalStorage_CallsServerStore()
{
var firstId = Guid.NewGuid();
var lastId = Guid.NewGuid();
var records = new Tuple <Guid, bool>[] {
new Tuple <Guid, bool>(firstId, false),
new Tuple <Guid, bool>(Guid.Empty, true),
new Tuple <Guid, bool>(lastId, true),
};
CreateWriteCache(WRITE_CACHE_FILE_INFO, records);
var localStorage = Substitute.For <IChattelLocalStorage>();
var server = Substitute.For <IAssetServer>();
var writer = new ChattelWriter(new ChattelConfiguration(server), localStorage, false);
var firstAsset = new StratusAsset {
Id = firstId,
};
var lastAsset = new StratusAsset {
Id = lastId,
};
localStorage.TryGetAsset(firstId, out var asset1).Returns(parms => { parms[1] = firstAsset; return(true); });
localStorage.TryGetAsset(lastId, out var asset2).Returns(parms => { parms[1] = lastAsset; return(true); });
localStorage.StoreAsset(firstAsset);
localStorage.StoreAsset(lastAsset);
new WriteCache(
WRITE_CACHE_FILE_INFO,
(uint)records.Length,
writer,
localStorage
);
server.Received().StoreAssetSync(firstAsset);
server.DidNotReceive().StoreAssetSync(lastAsset);
}
public static int Main(string[] args)
{
// First line, hook the appdomain to the crash reporter
AppDomain.CurrentDomain.UnhandledException += CurrentDomain_UnhandledException;
var waitHandle = new EventWaitHandle(false, EventResetMode.AutoReset, "70a9f94f-59e8-4073-93ab-00aaacc26111", out var createdNew);
if (!createdNew)
{
LOG.Error("Server process already started, please stop that server first.");
return(2);
}
// Add the arguments supplied when running the application to the configuration
var configSource = new ArgvConfigSource(args);
// Commandline switches
configSource.AddSwitch("Startup", "inifile");
configSource.AddSwitch("Startup", "logconfig");
configSource.AddSwitch("Startup", "pidfile");
configSource.AddSwitch("Startup", "purge");
var startupConfig = configSource.Configs["Startup"];
var pidFileManager = new PIDFileManager(startupConfig.GetString("pidfile", string.Empty));
// Configure Log4Net
{
var logConfigFile = startupConfig.GetString("logconfig", string.Empty);
if (string.IsNullOrEmpty(logConfigFile))
{
XmlConfigurator.Configure();
LogBootMessage();
LOG.Info("Configured log4net using ./WHIP_LRU.exe.config as the default.");
}
else
{
XmlConfigurator.Configure(new FileInfo(logConfigFile));
LogBootMessage();
LOG.Info($"Configured log4net using \"{logConfigFile}\" as configuration file.");
}
}
// Configure nIni aliases and locale
Thread.CurrentThread.CurrentCulture = new System.Globalization.CultureInfo("en-US", true);
configSource.Alias.AddAlias("On", true);
configSource.Alias.AddAlias("Off", false);
configSource.Alias.AddAlias("True", true);
configSource.Alias.AddAlias("False", false);
configSource.Alias.AddAlias("Yes", true);
configSource.Alias.AddAlias("No", false);
var isRunning = true;
WhipLru whipLru = null;
// Handlers for signals.
UnixSignal[] signals = null;
if (ON_POSIX_COMPLAINT_OS)
{
signals = new [] {
new UnixSignal(Signum.SIGINT),
new UnixSignal(Signum.SIGTERM),
new UnixSignal(Signum.SIGHUP),
};
}
else
{
Console.CancelKeyPress += (sender, cargs) => {
LOG.Debug("CTRL-C pressed, terminating.");
isRunning = false;
whipLru?.Stop();
cargs.Cancel = true;
waitHandle.Set();
};
}
while (isRunning)
{
// Dump any known servers, we're going to reconfigure them.
foreach (var server in _assetServersByName.Values)
{
server.Dispose();
}
// TODO: might need to double buffer these, or something, so that old ones can finish out before being disposed.
// Read in the ini file
ReadConfigurationFromINI(configSource);
// Read in a config list that lists the priority order of servers and their settings.
var configRead = configSource.Configs["AssetsRead"];
var configWrite = configSource.Configs["AssetsWrite"];
var serversRead = GetServers(configSource, configRead, _assetServersByName);
var serversWrite = GetServers(configSource, configWrite, _assetServersByName);
var localStorageConfig = configSource.Configs["LocalStorage"];
var chattelConfigRead = GetConfig(localStorageConfig, serversRead);
var chattelConfigWrite = GetConfig(localStorageConfig, serversWrite);
var serverConfig = configSource.Configs["Server"];
var address = serverConfig?.GetString("Address", WHIPServer.DEFAULT_ADDRESS) ?? WHIPServer.DEFAULT_ADDRESS;
var port = (uint?)serverConfig?.GetInt("Port", (int)WHIPServer.DEFAULT_PORT) ?? WHIPServer.DEFAULT_PORT;
var password = serverConfig?.GetString("Password", WHIPServer.DEFAULT_PASSWORD);
if (password == null) // Would only be null if serverConfig was null or DEFAULT_PASSWORD is null. Why not use the ?? operator? Compiler didn't like it.
{
password = WHIPServer.DEFAULT_PASSWORD;
}
var listenBacklogLength = (uint?)serverConfig?.GetInt("ConnectionQueueLength", (int)WHIPServer.DEFAULT_BACKLOG_LENGTH) ?? WHIPServer.DEFAULT_BACKLOG_LENGTH;
var maxAssetLocalStorageDiskSpaceByteCount = (ulong?)localStorageConfig?.GetLong("MaxDiskSpace", (long)AssetLocalStorageLmdbPartitionedLRU.DB_MAX_DISK_BYTES_MIN_RECOMMENDED) ?? AssetLocalStorageLmdbPartitionedLRU.DB_MAX_DISK_BYTES_MIN_RECOMMENDED;
var negativeCacheItemLifetime = TimeSpan.FromSeconds((uint?)localStorageConfig?.GetInt("NegativeCacheItemLifetimeSeconds", (int)StorageManager.DEFAULT_NC_LIFETIME_SECONDS) ?? StorageManager.DEFAULT_NC_LIFETIME_SECONDS);
var partitionInterval = TimeSpan.FromMinutes((uint?)localStorageConfig?.GetInt("MinutesBetweenDatabasePartitions", (int)DEFAULT_DB_PARTITION_INTERVAL_MINUTES) ?? DEFAULT_DB_PARTITION_INTERVAL_MINUTES);
var purgeAll = startupConfig.GetString("purge", string.Empty) == "all";
if (purgeAll)
{
LOG.Info("CLI request to purge all assets on startup specified.");
}
var readerLocalStorage = new AssetLocalStorageLmdbPartitionedLRU(
chattelConfigRead,
maxAssetLocalStorageDiskSpaceByteCount,
partitionInterval
);
var chattelReader = new ChattelReader(chattelConfigRead, readerLocalStorage, purgeAll);
var chattelWriter = new ChattelWriter(chattelConfigWrite, readerLocalStorage, purgeAll);
var storageManager = new StorageManager(
readerLocalStorage,
negativeCacheItemLifetime,
chattelReader,
chattelWriter
);
whipLru = new WhipLru(
address,
port,
password,
pidFileManager,
storageManager,
listenBacklogLength
);
whipLru.Start();
if (signals != null)
{
var signalIndex = UnixSignal.WaitAny(signals, -1);
switch (signals[signalIndex].Signum)
{
case Signum.SIGHUP:
whipLru.Stop();
break;
case Signum.SIGINT:
case Signum.SIGKILL:
isRunning = false;
whipLru.Stop();
break;
default:
// Signal unknown, ignore it.
break;
}
}
else
{
waitHandle.WaitOne();
}
}
foreach (var server in _assetServersByName.Values)
{
server.Dispose();
}
return(0);
}
public void Init()
{
// Configure Log4Net
XmlConfigurator.Configure(new FileInfo(Constants.LOG_CONFIG_PATH));
// Set CWD so that native libs are found.
Directory.SetCurrentDirectory(TestContext.CurrentContext.TestDirectory);
// Load INI stuff
var configSource = new ArgvConfigSource(new string[] { });
// Configure nIni aliases and locale
Thread.CurrentThread.CurrentCulture = new System.Globalization.CultureInfo("en-US", true);
configSource.Alias.AddAlias("On", true);
configSource.Alias.AddAlias("Off", false);
configSource.Alias.AddAlias("True", true);
configSource.Alias.AddAlias("False", false);
configSource.Alias.AddAlias("Yes", true);
configSource.Alias.AddAlias("No", false);
// Read in the ini file
configSource.Merge(new IniConfigSource(Constants.INI_PATH));
#pragma warning disable RECS0022 // A catch clause that catches System.Exception and has an empty body
try {
Directory.Delete(DATABASE_FOLDER_PATH, true);
}
catch (Exception) {
}
try {
File.Delete(WRITE_CACHE_FILE_PATH);
}
catch (Exception) {
}
#pragma warning restore RECS0022 // A catch clause that catches System.Exception and has an empty body
Directory.CreateDirectory(DATABASE_FOLDER_PATH);
// Start booting server
var pidFileManager = new LibWhipLru.Util.PIDFileManager(Constants.PID_FILE_PATH);
var chattelConfigRead = new ChattelConfiguration(DATABASE_FOLDER_PATH);
var chattelConfigWrite = new ChattelConfiguration(DATABASE_FOLDER_PATH);
var readerLocalStorage = new LibWhipLru.Cache.AssetLocalStorageLmdbPartitionedLRU(
chattelConfigRead,
DATABASE_MAX_SIZE_BYTES,
TimeSpan.FromSeconds(1)
);
var chattelReader = new ChattelReader(chattelConfigRead, readerLocalStorage);
var chattelWriter = new ChattelWriter(chattelConfigWrite, readerLocalStorage);
var storageManager = new LibWhipLru.Cache.StorageManager(
readerLocalStorage,
TimeSpan.FromMinutes(2),
chattelReader,
chattelWriter
);
_service = new WhipLru(
Constants.SERVICE_ADDRESS,
Constants.SERVICE_PORT,
Constants.PASSWORD,
pidFileManager,
storageManager
);
_service.Start();
}
