private void CommonHandle(Message message)
{
if (BlockWriter && !(message is SystemMessage.StateChangeMessage))
{
Log.Verbose("Blocking message {message} in StorageWriterService. Message:", message.GetType().Name);
Log.Verbose("{message}", message);
return;
}
if (_vnodeState != VNodeState.Leader && _vnodeState != VNodeState.ResigningLeader && message is StorageMessage.ILeaderWriteMessage)
{
Log.Fatal("{message} appeared in StorageWriter during state {vnodeStrate}.", message.GetType().Name,
_vnodeState);
var msg = String.Format("{0} appeared in StorageWriter during state {1}.", message.GetType().Name,
_vnodeState);
Application.Exit(ExitCode.Error, msg);
return;
}
try {
_writerBus.Handle(message);
} catch (Exception exc) {
BlockWriter = true;
Log.Fatal(exc, "Unexpected error in StorageWriterService. Terminating the process...");
Application.Exit(ExitCode.Error,
string.Format("Unexpected error in StorageWriterService: {0}", exc.Message));
}
}
//public EditorState GetActiveEditorState() {
// return GetActiveEditorState(out IVsTextView textView);
//}
// someday, this can return...
//public bool QueryExtensions(string author, params string[] names)
//{
// if (_extensionManager == null)
// {
// Log.Debug($"{nameof(_extensionManager)} is null");
// return false;
// }
// foreach (var extension in _extensionManager.GetInstalledExtensions())
// {
// IExtensionHeader header = extension.Header;
// if (!header.SystemComponent &&
// header.Author.EqualsIgnoreCase(author) && names.Any(_ => _.EqualsIgnoreCase(header.Name)))
// {
// return true;
// }
// }
// return false;
//}
/// <summary>
/// Tries to get an active text view for a file that may have just opened.
/// Uses a naive exponential backoff algorithm against the IsDocumentOpen VSShell utility
/// </summary>
/// <param name="filePath"></param>
/// <returns></returns>
/// <remarks>https://stackoverflow.com/a/7373385/208022</remarks>
internal IWpfTextView TryGetPendingWpfTextView(string filePath)
{
var editorAdapterFactoryService = _componentModel.GetService <IVsEditorAdaptersFactoryService>();
IVsUIHierarchy uiHierarchy;
uint itemID;
IVsWindowFrame windowFrame = null;
if (Retry.WithExponentialBackoff(() => {
if (VsShellUtilities.IsDocumentOpen(
_serviceProvider,
filePath,
Guid.Empty,
out uiHierarchy,
out itemID,
out windowFrame))
{
return(true);
}
return(false);
}))
{
if (windowFrame == null)
{
return(null);
}
IVsTextView view = VsShellUtilities.GetTextView(windowFrame);
Log.Verbose($"{nameof(TryGetPendingWpfTextView)} found for {filePath}");
return(editorAdapterFactoryService.GetWpfTextView(view));
}
return(null);
}
internal void Start(TApplication instance)
{
Application = instance;
var bits = IntPtr.Size == 4 ? 32 : 64;
Log.Verbose($"{bits} Bit System detected. (Pointer Size: {IntPtr.Size} Bytes)");
Log.Verbose("OS: {OSVersion}", Environment.OSVersion);
if (Config.UseGtkUI)
{
Log.Verbose("Init GtkUI");
ui = CreateGtkUI();
ui.Start();
Log.Verbose("GtkUI initialized");
}
if (Config.UseConsole)
{
Log.Verbose("Configure for console session");
th = new Thread(UIThreadMain);
th.Start();
ConsoleLoop();
Application.Stop();
Application.Dispose();
th.Abort();
Environment.Exit(0);
}
else
{
UIThreadMain();
Environment.Exit(0);
}
}
/// <summary>
/// Dumps a type as script, if the script is not already existing.
/// </summary>
/// <param name="type">Type that should be dumped.</param>
/// <param name="guids">
/// Dictionary of types and guids that have been dumped.
/// If the return value is <see langword="false"/>, this will be <see langword="null" />
/// </param>
/// <returns><see langword="true"/> if the type was dumped, <see langword="false"/> otherwise.</returns>
public bool DumpIfNotExists(Type type, out Dictionary <Type, string> guids)
{
type = type.DeArray().GetRoot();
if (type.IsGenericType)
{
foreach (var arg in type.GetGenericArguments())
{
if (arg.IsGenericParameter)
{
continue;
}
referencedTypes.Enqueue(arg);
}
type = type.GetGenericTypeDefinition();
}
if (!dumpedTypes.Add(type) || !ShouldDumpType(type))
{
logger.Verbose("Do not dump {Type} (ShouldDump: {Bool})", type.FullName, ShouldDumpType(type));
guids = null;
return(false);
}
guids = new Dictionary <Type, string>();
guids[type] = DumpType(type);
// Dump all referenced types
while (referencedTypes.Count > 0)
{
var childType = referencedTypes.Dequeue().DeArray().GetRoot();
if (childType.IsGenericType)
{
foreach (var arg in childType.GetGenericArguments())
{
if (arg.IsGenericParameter)
{
continue;
}
referencedTypes.Enqueue(arg);
}
childType = childType.GetGenericTypeDefinition();
}
if (!dumpedTypes.Add(childType) || !ShouldDumpType(childType))
{
continue;
}
guids[childType] = DumpType(childType);
}
return(true);
}
public void Handle(ReplicationMessage.RawChunkBulk message)
{
if (_subscriptionId != message.SubscriptionId)
{
return;
}
if (_activeChunk == null)
{
ReplicationFail(
"Physical chunk bulk received, but we do not have active chunk.",
"Physical chunk bulk received, but we do not have active chunk.");
}
if (_activeChunk.ChunkHeader.ChunkStartNumber != message.ChunkStartNumber ||
_activeChunk.ChunkHeader.ChunkEndNumber != message.ChunkEndNumber)
{
Log.Error(
"Received RawChunkBulk for TFChunk {chunkStartNumber}-{chunkEndNumber}, but active chunk is {activeChunk}.",
message.ChunkStartNumber, message.ChunkEndNumber, _activeChunk);
return;
}
if (_activeChunk.RawWriterPosition != message.RawPosition)
{
Log.Error(
"Received RawChunkBulk at raw pos {rawPosition} (0x{rawPosition:X}) while current writer raw pos is {rawWriterPosition} (0x{rawWriterPosition:X}).",
message.RawPosition, message.RawPosition, _activeChunk.RawWriterPosition,
_activeChunk.RawWriterPosition);
return;
}
if (!_activeChunk.TryAppendRawData(message.RawBytes))
{
ReplicationFail(
"Could not append raw bytes to chunk {0}-{1}, raw pos: {2} (0x{3:X}), bytes length: {4} (0x{5:X}). Chunk file size: {6} (0x{7:X}).",
"Could not append raw bytes to chunk {chunkStartNumber}-{chunkEndNumber}, raw pos: {rawPosition} (0x{rawPosition:X}), bytes length: {rawBytesLength} (0x{rawBytesLength:X}). Chunk file size: {chunkFileSize} (0x{chunkFileSize:X}).",
message.ChunkStartNumber, message.ChunkEndNumber, message.RawPosition, message.RawPosition,
message.RawBytes.Length, message.RawBytes.Length, _activeChunk.FileSize, _activeChunk.FileSize);
}
_subscriptionPos += message.RawBytes.Length;
if (message.CompleteChunk)
{
Log.Verbose("Completing raw chunk {chunkStartNumber}-{chunkEndNumber}...", message.ChunkStartNumber,
message.ChunkEndNumber);
Writer.CompleteReplicatedRawChunk(_activeChunk);
_subscriptionPos = _activeChunk.ChunkHeader.ChunkEndPosition;
_framer.Reset();
_activeChunk = null;
}
if (message.CompleteChunk || _subscriptionPos > _ackedSubscriptionPos)
{
_ackedSubscriptionPos = _subscriptionPos;
Bus.Publish(new ReplicationMessage.AckLogPosition(_subscriptionId, _ackedSubscriptionPos));
}
}
private void AddRef()
{
// if (ObjectLabel.IsUnset())
// throw new Exception("ObjectLabel not set!");
Log.Verbose("Alloc Texture #{Handle} {ObjectLabel}", Handle, ObjectLabel);
InternalTextureManager.AddRef(this);
}
public void Intercept(IInvocation invocation)
{
_logger.Verbose("Calling method: {0} with parameters: {1}... ",
invocation.Method.Name,
string.Join(", ", invocation.Arguments.Select(a => (a ?? "").ToString()).ToArray()));
invocation.Proceed();
_logger.Verbose("The method: {methodName} return value was {@Return}.", invocation.Method.Name, invocation.ReturnValue);
}
public TestBase()
{
DebugHelper.LogThreadInfo("UnitTestThread");
Log.Verbose("Waiting for {Name}", nameof(AppWaiter));
AppWaiter.WaitOne();
Log.Verbose("Waiting {Name} done", nameof(AppWaiter));
App = new TestsApplication();
App.Run();
Console.WriteLine("Ready for tests");
}
/// <summary>
/// Logs the specified log event.
/// </summary>
/// <param name="logEvent">The <see cref="T:Swan.LogMessageReceivedEventArgs" /> instance containing the event data.</param>
public void Log(LogMessageReceivedEventArgs logEvent)
{
switch (logEvent.MessageType)
{
case LogLevel.None:
break;
case LogLevel.Info:
_logger.Information("{@logEvent}", logEvent);
break;
case LogLevel.Trace:
_logger.Verbose("{@logEvent}", logEvent);
break;
case LogLevel.Debug:
_logger.Debug("{@logEvent}", logEvent);
break;
case LogLevel.Warning:
_logger.Warning("{@logEvent}", logEvent);
break;
case LogLevel.Error:
_logger.Error("{@logEvent}", logEvent);
break;
case LogLevel.Fatal:
_logger.Fatal("{@logEvent}", logEvent);
break;
}
}
public void Publish(Message message)
{
//if (message == null) throw new ArgumentNullException("message");
var handlers = _handlers[message.MsgTypeId];
for (int i = 0, n = handlers.Count; i < n; ++i)
{
var handler = handlers[i];
if (_watchSlowMsg)
{
var start = DateTime.UtcNow;
handler.TryHandle(message);
var elapsed = DateTime.UtcNow - start;
if (elapsed > _slowMsgThreshold)
{
Log.Verbose("SLOW BUS MSG [{bus}]: {message} - {elapsed}ms. Handler: {handler}.",
Name, message.GetType().Name, (int)elapsed.TotalMilliseconds, handler.HandlerName);
if (elapsed > QueuedHandler.VerySlowMsgThreshold && !(message is SystemMessage.SystemInit))
{
Log.Error("---!!! VERY SLOW BUS MSG [{bus}]: {message} - {elapsed}ms. Handler: {handler}.",
Name, message.GetType().Name, (int)elapsed.TotalMilliseconds, handler.HandlerName);
}
}
}
else
{
handler.TryHandle(message);
}
}
}
private static void AttachTraceLogToCrashReport(ILogger log)
{
var info = new DirectoryInfo(FileSystem.AppDataDirectory);
var textFiles = info.EnumerateFiles("*.txt");
var lastFile = textFiles.OrderByDescending(t => t.LastWriteTime).FirstOrDefault();
if (lastFile == null)
{
log.Verbose("Log file was not found");
return;
}
try
{
var logFilePath = lastFile.FullName;
var tempPath = Path.Combine(FileSystem.CacheDirectory, lastFile.Name + "-temp");
if (File.Exists(tempPath))
{
File.Delete(tempPath);
}
File.Copy(logFilePath, tempPath);
var traceLog = File.ReadAllText(tempPath);
Crashes.GetErrorAttachments = report => new[]
{
ErrorAttachmentLog.AttachmentWithText(traceLog, "traceLog.txt")
};
}
catch (Exception e)
{
log.Error(e, "Failed to parse text in traceLog");
}
}
/// <summary>
/// 启动数据库运行
/// </summary>
/// <param name="dataBasePath">数据库路径</param>
public void Start(string dataBasePath = null)
{
if (dataBasePath != null)
{
this.DataBasePath = dataBasePath;
}
_db = new SQLiteConnectionWithLock(new SQLiteConnectionString(
DataBasePath,
SQLiteOpenFlags.Create | SQLiteOpenFlags.ReadWrite | SQLiteOpenFlags.FullMutex, true))
{
// debug log
Trace = true,
TimeExecution = true,
Tracer = s => Log?.Verbose(" [pid={0}] {1}", Thread.CurrentThread.ManagedThreadId, s),
BusyTimeout = TimeSpan.FromMilliseconds(5000),
SkipLock = false
};
// 创建表，这个库会自动处理数据结构变更和重复创建
foreach (var type in _createTableList)
{
_db.CreateTable(type);
}
updateTableDelegates[DataBaseType.GunDevelop] = new UpdateTableDelegate(UpdateGunDevelopTotal);
updateTableDelegates[DataBaseType.GunDevelopHeavy] = new UpdateTableDelegate(UpdateGunDevelopHeavyTotal);
updateTableDelegates[DataBaseType.EquipDevelop] = new UpdateTableDelegate(UpdateEquipDevelopTotal);
updateTableDelegates[DataBaseType.EquipProduce] = new UpdateTableDelegate(UpdateEquipProduceTotal);
updateTableDelegates[DataBaseType.EquipDevelopHeavy] = new UpdateTableDelegate(UpdateEquipDevelopHeavyTotal);
updateTableDelegates[DataBaseType.MissionBattle] = new UpdateTableDelegate(UpdateMissionBattleTotal);
updateTableDelegates[DataBaseType.MissionFinish] = new UpdateTableDelegate(UpdateMissionFinishTotal);
}
/// <summary>
/// Write a message with the given severity to the logs. Takes a StringBuilder to allow for minimal allocation.
/// </summary>
/// <param name="logLevel">The severity level of the log message.</param>
/// <param name="logMessage">The log message itself in StringBuilder form for manipulation.</param>
/// <param name="callerName">The name of the calling method.</param>
/// <param name="callerSourceFile">The name of the source file of the caller.</param>
/// <param name="callerLineNumber">The line number where the log is being called.</param>
private void Write(
LogLevel logLevel,
StringBuilder logMessage,
[CallerMemberName] string callerName = null,
[CallerFilePath] string callerSourceFile = null,
[CallerLineNumber] int callerLineNumber = 0)
{
string indentedLogMsg = IndentMsg(logMessage);
string logLevelName = logLevel.ToString().ToUpper();
int threadId = Thread.CurrentThread.ManagedThreadId;
switch (logLevel)
{
case LogLevel.Diagnostic:
_logger.Verbose(s_logMessageTemplate, logLevelName, threadId, callerName, callerSourceFile, callerLineNumber, indentedLogMsg);
return;
case LogLevel.Verbose:
_logger.Debug(s_logMessageTemplate, logLevelName, threadId, callerName, callerSourceFile, callerLineNumber, indentedLogMsg);
return;
case LogLevel.Normal:
_logger.Information(s_logMessageTemplate, logLevelName, threadId, callerName, callerSourceFile, callerLineNumber, indentedLogMsg);
return;
case LogLevel.Warning:
_logger.Warning(s_logMessageTemplate, logLevelName, threadId, callerName, callerSourceFile, callerLineNumber, indentedLogMsg);
return;
case LogLevel.Error:
_logger.Error(s_logMessageTemplate, logLevelName, threadId, callerName, callerSourceFile, callerLineNumber, indentedLogMsg);
return;
}
}
public void Log(LogEntry entry)
{
switch (entry.Severity)
{
case LoggingEventType.Verbose:
_logger.Verbose(entry.Exception, entry.Message, entry.Args);
break;
case LoggingEventType.Debug:
_logger.Debug(entry.Exception, entry.Message, entry.Args);
break;
case LoggingEventType.Information:
_logger.Information(entry.Exception, entry.Message, entry.Args);
break;
case LoggingEventType.Warning:
_logger.Warning(entry.Exception, entry.Message, entry.Args);
break;
case LoggingEventType.Error:
_logger.Error(entry.Exception, entry.Message, entry.Args);
break;
case LoggingEventType.Fatal:
_logger.Fatal(entry.Exception, entry.Message, entry.Args);
break;
default:
throw new ArgumentException($"Severity {entry.Severity} is not supported by SerilogAdapter", "Severity");
}
}
public bool WriteCore(TraceEventType eventType, int eventId, object state, Exception exception, Func <object, Exception, string> formatter)
{
var log = new OwinContextLog(eventId, formatter(state, exception));
switch (eventType)
{
case TraceEventType.Critical:
_logger.Fatal(exception, SerilogMessage, log);
return(true);
case TraceEventType.Error:
_logger.Error(exception, SerilogMessage, log);
return(true);
case TraceEventType.Information:
_logger.Information(exception, SerilogMessage, log);
return(true);
case TraceEventType.Warning:
_logger.Warning(exception, SerilogMessage, log);
return(true);
case TraceEventType.Verbose:
_logger.Verbose(exception, SerilogMessage, log);
return(true);
default:
return(false);
}
}
private static void CheckCache()
{
var cacheVersionFile = Path.Combine(GlobalCacheDir, "cacheinfo.json");
var assemblyVersion = typeof(AssetManager).Assembly.GetName().Version.ToString();
if (Directory.Exists(GlobalCacheDir))
{
var deleteDir = true;
try
{
if (File.Exists(cacheVersionFile))
{
var versionInfo = JsonConvert.DeserializeObject <CacheInfo>(File.ReadAllText(cacheVersionFile));
if (versionInfo.AssemblyVersion == assemblyVersion)
{
deleteDir = false;
}
}
}
catch (Exception ex)
{
Log.Error(ex);
}
if (deleteDir)
{
Log.Verbose("Delete Cache directory: {Path}", GlobalCacheDir);
Directory.Delete(GlobalCacheDir, true);
var n = 10;
while (Directory.Exists(GlobalCacheDir) && n-- > 0)
{
Thread.Sleep(1000);
}
}
}
if (!Directory.Exists(GlobalCacheDir))
{
Log.Verbose("Create Cache directory: {Path}", GlobalCacheDir);
Directory.CreateDirectory(GlobalCacheDir);
var versionInfo = new CacheInfo {
AssemblyVersion = assemblyVersion
};
File.WriteAllText(cacheVersionFile, JsonConvert.SerializeObject(versionInfo));
}
}
public void RegisterControllerActions(IHttpService service)
{
var pattern = _localWebRootPath + "/{*remaining_path}";
Logger.Verbose("Binding MiniWeb to {path}", pattern);
service.RegisterAction(
new ControllerAction(pattern, HttpMethod.Get, Codec.NoCodecs, new ICodec[] { Codec.ManualEncoding }, new Operation(Operations.Node.StaticContent)),
OnStaticContent);
}
private void OnSessionCreated(object sender, SessionEventArgs e)
{
e.Context.CommandExecuting += (o, args) =>
{
_logger.Verbose("SMTP Command {@SmtpCommand}", args.Command);
};
_logger.Information("New SMTP connection from {EndpointAddress}", e.Context.EndpointDefinition.Endpoint.Address.ToString());
}
public void Handle(StorageMessage.AlreadyCommitted message)
{
if (Interlocked.Read(ref _complete) == 1 || _allEventsWritten)
{
return;
}
Log.Verbose("IDEMPOTENT WRITE TO STREAM ClientCorrelationID {clientCorrelationId}, {message}.", ClientCorrId,
message);
ReturnCommitAt(message.LogPosition, message.FirstEventNumber, message.LastEventNumber);
}
internal override void DoDeallocation()
{
if (!HasDeallocation)
{
return;
}
if (RendererTexture == null)
{
return;
}
Log.Verbose("Set InternalTexture.Orphaned");
RendererTexture.Orphaned = true;
RendererTexture = null;
base.DoDeallocation();
}
public QueueStats[] GetStats()
{
var stats = _queues.Keys.OrderBy(x => x.Name).Select(queue => queue.GetStatistics()).ToArray();
if (Application.IsDefined(Application.DumpStatistics))
{
Log.Verbose(Environment.NewLine + string.Join(Environment.NewLine, stats.Select(x => x.ToString())));
}
return(stats);
}
protected override void OnMouseDown(MouseButtonArgs e)
{
if (CurrentMouseWorldPositionIsValid)
{
var translatedPos = (new Vector4(CurrentMouseWorldPosition, 1) * BoardTranslationMatrix).Xyz;
Console.WriteLine(translatedPos);
var pos = translatedPos.Round().Xy.ToVector2i();
if (!Board.PositionInMap(pos))
{
return;
}
//ScaleAnim.Start();
var selector = BoardActor.GetComponent <SceneComponent>("MarbleSelector");
if (MoveTween.Enabled || RemoveTween.Enabled || CreateTween.Enabled)
{
return;
}
if (Board[pos]?.Color == MarbleColor.BombJoker)
{
return;
}
var marble = Board[pos];
Log.Verbose("Clicked: {position}. Marble: {marble}", pos, marble);
if (marble != null)
{
SelectedMarble = marble;
selector.RelativeTranslation = new Vector3(pos.X, pos.Y, selector.RelativeTranslation.Z);
selector.Visible = true;
AudioManager.Default.PlayAsync("Sounds/marble-select.wav");
}
else
{
if (SelectedMarble != null)
{
var path = Board.FindPath(SelectedMarble, pos);
if (path != null && path.Count > 0)
{
CurrentPath = path;
var moveStepDuration = TimeSpan.FromSeconds(0.1);
//var moveStepDuration = TimeSpan.FromSeconds(2);
MoveTween.Duration = moveStepDuration.Multiply(path.Count);
MoveTween.Start();
AudioManager.Default.PlayAsync("Sounds/marble-moving.wav");
selector.Visible = false;
}
}
}
}
}
public IActionResult Serilog()
{
_serilogLogger.Verbose("Serilog Verbose");
_serilogLogger.Debug("Serilog Debug");
_serilogLogger.Information("Serilog Information");
_serilogLogger.Warning("Serilog Warning");
_serilogLogger.Error("Serilog Error");
_serilogLogger.Fatal("Serilog Fatal");
return(Ok());
}
public HydrogenApplicationContext(ApplicationTenant tenant, bool migrate, Serilog.ILogger log)
{
_tenant = tenant;
_log = log;
if (_tenant == null)
{
throw new Exception("Unable to identify database connection for tenant.");
}
this.LogToConsole();
log.Verbose("Using {tenant} database.", tenant.Name);
InitializeDatabase(migrate);
}
private void OnRenderFrameInternal(FrameEventArgs e)
{
if (!RenderInitialized)
{
Log.Verbose("Init OpenGL Bindings");
Log.Verbose("Grab Context");
Window.MakeCurrent();
Log.Verbose("Load OpenGL Bindings");
GL.LoadBindings(new GLFWBindingsContext());
var vendor = GL.GetString(StringName.Vendor);
var version = GL.GetString(StringName.Version);
var shadingLanguageVersion = GL.GetString(StringName.ShadingLanguageVersion);
var renderer = GL.GetString(StringName.Renderer);
Log.Info($"Vendor: {vendor}, version: {version}, shadinglangVersion: {shadingLanguageVersion}, renderer: {renderer}");
EnableDebugCallback();
RenderInitialized = true;
}
if (!RenderThreadHasContext)
{
Window.MakeCurrent();
RenderThreadHasContext = true;
}
SetRenderThread();
RenderReady = true;
if (Enabled)
{
RenderFrame?.Invoke(e);
}
}
public static bool IsPresent(int pid)
{
var mutexName = string.Format("ESCLUSTERNODE:{0}", pid);
try {
using (Mutex.OpenExisting(mutexName)) {
return(true);
}
} catch (WaitHandleCannotBeOpenedException) {
return(false);
} catch (Exception exc) {
Log.Verbose(exc, "Exception while trying to open Cluster Node mutex '{mutex}': {e}.", mutexName,
exc.Message);
}
return(false);
}
internal override void DoDeallocation()
{
if (!HasDeallocation)
{
return;
}
if (RenderableObject == null)
{
return;
}
Log.Verbose("Set RenderableObject.Orphaned");
RenderableObject.Orphaned = true;
RenderableObject = null;
base.DoDeallocation();
}
public void Handle(ClientMessage.WriteEventsCompleted message)
{
if (message.CorrelationId != _streamMetadataWriteCorrId)
{
return;
}
switch (message.Result)
{
case OperationResult.Success:
case OperationResult.WrongExpectedVersion: // already created
{
Log.Verbose("Created stats stream '{stream}', code = {result}", _nodeStatsStream, message.Result);
_statsStreamCreated = true;
break;
}
case OperationResult.PrepareTimeout:
case OperationResult.CommitTimeout:
case OperationResult.ForwardTimeout: {
Log.Debug("Failed to create stats stream '{stream}'. Reason : {e}({message}). Retrying...",
_nodeStatsStream, message.Result, message.Message);
SetStatsStreamMetadata();
break;
}
case OperationResult.AccessDenied: {
// can't do anything about that right now
break;
}
case OperationResult.StreamDeleted:
case OperationResult.InvalidTransaction: // should not happen at all
{
Log.Error(
"Monitoring service got unexpected response code when trying to create stats stream ({e}).",
message.Result);
break;
}
default:
throw new ArgumentOutOfRangeException();
}
}
//Automerge only
private void TryProcessAwaitingTables(long commitPos, long prepareCheckpoint)
{
lock (_awaitingTablesLock) {
var newTables = new List <TableItem> {
new TableItem(_memTableFactory(), -1, -1, 0)
};
newTables.AddRange(_awaitingMemTables.Select(
(x, i) => i == 0 ? new TableItem(x.Table, prepareCheckpoint, commitPos, x.Level) : x));
Log.Verbose("Switching MemTable, currently: {awaitingMemTables} awaiting tables.", newTables.Count);
_awaitingMemTables = newTables;
if (_inMem)
{
return;
}
TryProcessAwaitingTables();
if (_additionalReclaim)
{
ThreadPool.QueueUserWorkItem(x => ReclaimMemoryIfNeeded(_awaitingMemTables));
}
}
}
public RenderWindow(ApplicationConfig config)
: base(new GameWindowSettings {
IsMultiThreaded = config.IsMultiThreaded, UpdateFrequency = config.UpdateFrequency, RenderFrequency = config.RenderFrequency
}, new NativeWindowSettings {
Size = config.WindowSize
})
{
Log.Verbose("Created window");
Config = config;
Title = Config.WindowTitle;
if (Config.WindowLocation != null)
{
Location = (Vector2i)Config.WindowLocation;
}
var vsync = Config.VSync;
if (Environment.OSVersion.Platform == PlatformID.Win32NT && IsMultiThreaded && Config.VSync == VSyncMode.Adaptive)
{
Log.Warn("BUG: OSVersion=mswin, IsMultiThreaded=true Config.VSync=VSyncMode.Adaptive: Force VSyncMode.On");
vsync = VSyncMode.On;
}
VSync = vsync;
if (Config.HideTitleBar && Environment.OSVersion.Platform == PlatformID.Win32NT)
{
Win32Native.HideTitleBar();
}
Size = Config.WindowSize;
var diff = Size - Config.WindowSize;
if (diff != Vector2i.Zero)
{
Size = Config.WindowSize - diff;
}
}