public static void OnLogReceive(string level, string message) { #if DEBUG && DEBUG_LOG_INTERCEPTOR App.Logger.Debug("l: {0} m: {1}", level, message); #endif #if DEBUG LogReceived?.Invoke(Application.Current, new LogInterceptedEventArgs(message, level)); #elif RELEASE switch (level) { case "Warn": LogReceived?.Invoke(null, new LogInterceptedEventArgs(message, "Предупреждение:")); break; case "Error": LogReceived?.Invoke(null, new LogInterceptedEventArgs(message, "Ошибка:")); break; case "Fatal": LogReceived?.Invoke(null, new LogInterceptedEventArgs(message, "Критическая ошибка:")); break; default: LogReceived?.Invoke(null, new LogInterceptedEventArgs(message, "")); break; } #endif }
public async Task <bool> LaunchGameAsync(LaunchProfile profile, Version version) { var startInfo = new ProcessStartInfo { FileName = profile.IsDebugMode ? _gamePathService.JavaPath : _gamePathService.JavawPath, WorkingDirectory = _gamePathService.WorkingDir, Arguments = BuildArguments(profile, version), UseShellExecute = profile.IsDebugMode, RedirectStandardOutput = !profile.IsDebugMode, RedirectStandardError = !profile.IsDebugMode, }; _gameProcess = Process.Start(startInfo); _gameProcess.EnableRaisingEvents = true; _gameProcess.Exited += (s, e) => Exited?.Invoke(_gameProcess.ExitCode); if (!profile.IsDebugMode) { _gameProcess.ErrorDataReceived += (s, e) => ErrorReceived?.Invoke(e.Data); _gameProcess.BeginErrorReadLine(); _gameProcess.OutputDataReceived += (s, e) => LogReceived?.Invoke(e.Data); _gameProcess.BeginOutputReadLine(); if (!_gameProcess.HasExited) { await Task.Run(() => _gameProcess.WaitForInputIdle()); } } return(!_gameProcess.HasExited); }
public static void RaiseLogEvent(LogEvent logEvent, IFormatProvider formatProvider) { LogReceived?.Invoke(null, new LogReceivedEventArgs() { LogEvent = logEvent, FormatProvider = formatProvider }); }
public override void OnWireReceived(UnsafeReader reader) { var version = reader.ReadInt(); var value = ReadValueDelegate(SerializationContext, reader); var rejected = IsMaster && version < myMasterVersion; if (LogReceived.IsTraceEnabled()) { LogReceived.Trace("property `{0}` ({1}):: oldver = {2}, newver = {3}, value = {4}{5}", Location, RdId, myMasterVersion, version, value.PrintToString(), rejected ? " REJECTED" : ""); } if (rejected) { return; } myMasterVersion = version; using (UsingDebugInfo()) { myProperty.Value = value; } }
public void LogMessage(LogLevel logLevel, string message) { switch (logLevel) { case LogLevel.Critical: _logger.Fatal(message); LogReceived?.Invoke(LogEventLevel.Fatal, _logger, message, _application); break; case LogLevel.Debug: _logger.Debug(message); LogReceived?.Invoke(LogEventLevel.Debug, _logger, message, _application); break; case LogLevel.Information: _logger.Information(message); LogReceived?.Invoke(LogEventLevel.Information, _logger, message, _application); break; case LogLevel.Warning: _logger.Warning(message); LogReceived?.Invoke(LogEventLevel.Warning, _logger, message, _application); break; case LogLevel.Error: _logger.Error(message); LogReceived?.Invoke(LogEventLevel.Error, _logger, message, _application); break; default: throw new ArgumentOutOfRangeException(nameof(logLevel), logLevel, null); } }
/// <summary> /// Gets the configured <see cref="ISqlBuilder"/> for the specified <see cref="IDbConnection"/> instance. /// </summary> /// <param name="connection">The database connection instance.</param> /// <returns>The <see cref="ISqlBuilder"/> interface for the specified <see cref="IDbConnection"/> instance.</returns> public static ISqlBuilder GetSqlBuilder(IDbConnection connection) { var connectionTypeName = connection.GetType().Name; var builder = SqlBuilders.TryGetValue(connectionTypeName.ToLower(), out var b) ? b : new SqlServerSqlBuilder(); LogReceived?.Invoke($"Selected SQL Builder '{builder.GetType().Name}' for connection type '{connectionTypeName}'"); return(builder); }
/// <summary> /// Error handler to rethrow wkhtmltopdf log events. /// </summary> /// <param name="sender">Event sender.</param> /// <param name="e">Instance of <see cref="DataReceivedEventArgs"/>.</param> private void ErrorDataHandler(object sender, DataReceivedEventArgs e) { if (!string.IsNullOrEmpty(e?.Data)) { _lastLogLine = e.Data; LogReceived?.Invoke(this, e); } }
public override void OnWireReceived(UnsafeReader reader) { var taskId = RdId.Read(reader); var value = ReadRequestDelegate(SerializationContext, reader); if (LogReceived.IsTraceEnabled()) { LogReceived.Trace("endpoint `{0}`::({1}), taskId={2}, request = {3}", Location, RdId, taskId, value.PrintToString()); } RdTask <TRes> rdTask; using (UsingDebugInfo()) //now supports only sync handlers { try { rdTask = Handler(myBindLifetime, value); } catch (OperationCanceledException) { rdTask = RdTask <TRes> .Cancelled(); } catch (Exception e) { rdTask = RdTask <TRes> .Faulted(e); } } rdTask.Result.Advise(myBindLifetime, result => { if (LogSend.IsTraceEnabled()) { LogSend.Trace("endpoint `{0}`::({1}), taskId={2}, response = {3}", Location, RdId, taskId, result.PrintToString()); } RdTaskResult <TRes> validatedResult; try { if (result.Status == RdTaskStatus.Success) { AssertNullability(result.Result); } validatedResult = result; } catch (Exception e) { LogSend.Error(e); validatedResult = RdTaskResult <TRes> .Faulted(e); } Wire.Send(RdId, (writer) => { taskId.Write(writer); RdTaskResult <TRes> .Write(WriteResponseDelegate, SerializationContext, writer, validatedResult); }); }); }
internal StdIOTransport(Process process, TransportTaskScheduler scheduler = null) { _process = process; scheduler ??= ScheduleTransportTask; process.ErrorDataReceived += (s, e) => LogReceived?.Invoke(this, new LogReceivedEventArgs(e.Data)); process.BeginErrorReadLine(); scheduler(GetResponseAsync, _readerCancellationSource.Token); }
void Log(object message) { Debug.WriteLine($"[{DateTime.Now.ToString(CultureInfo.CurrentCulture)} ]: {message}"); try { LogReceived?.Invoke(this, message); } catch { } }
public void Log(string log, LogType type = LogType.Information) { logStream.Log(log, this, type); LogReceived.Invoke(this, new LogEventArgs { Log = $"[{DateTime.Now.ToShortTimeString()}] {URL.Host}: {log}", Type = type, }); }
public override void OnWireReceived(UnsafeReader reader) { var value = myReadValue(SerializationContext, reader); if (LogReceived.IsTraceEnabled()) { LogReceived.Trace("signal `{0}` ({1}):: value = {2}", Location, RdId, value.PrintToString()); } using (UsingDebugInfo()) mySignal.Fire(value); }
/// <summary> /// Gets the key properties for the specified type, using the configured <see cref="IKeyPropertyResolver"/>. /// </summary> /// <param name="type">The <see cref="Type"/> to get the key properties for.</param> /// <returns>The key properties for <paramref name="type"/>.</returns> public static KeyPropertyInfo[] KeyProperties(Type type) { if (!_typeKeyPropertiesCache.TryGetValue(type, out var keyProperties)) { keyProperties = KeyPropertyResolver.ResolveKeyProperties(type); _typeKeyPropertiesCache.TryAdd(type, keyProperties); } LogReceived?.Invoke($"Resolved property '{string.Join(", ", keyProperties.Select(p => p.Property.Name))}' as key property for '{type}'"); return(keyProperties); }
/// <summary> /// Gets the name of the column in the database for the specified type, /// using the configured <see cref="IColumnNameResolver"/>. /// </summary> /// <param name="propertyInfo">The <see cref="PropertyInfo"/> to get the column name for.</param> /// <param name="sqlBuilder">The SQL builder instance.</param> /// <returns>The column name in the database for <paramref name="propertyInfo"/>.</returns> public static string Column(PropertyInfo propertyInfo, ISqlBuilder sqlBuilder) { var key = $"{sqlBuilder.GetType()}.{propertyInfo.DeclaringType}.{propertyInfo.Name}"; if (!_columnNameCache.TryGetValue(key, out var columnName)) { columnName = sqlBuilder.QuoteIdentifier(_columnNameResolver.ResolveColumnName(propertyInfo)); _columnNameCache.TryAdd(key, columnName); } LogReceived?.Invoke($"Resolved column name '{columnName}' for '{propertyInfo}'"); return(columnName); }
/// <summary> /// Gets the name of the table in the database for the specified type, /// using the configured <see cref="ITableNameResolver"/>. /// </summary> /// <param name="type">The <see cref="Type"/> to get the table name for.</param> /// <param name="sqlBuilder">The SQL builder instance.</param> /// <returns>The table name in the database for <paramref name="type"/>.</returns> public static string Table(Type type, ISqlBuilder sqlBuilder) { var key = $"{sqlBuilder.GetType()}.{type}"; if (!_typeTableNameCache.TryGetValue(key, out var name)) { name = sqlBuilder.QuoteIdentifier(_tableNameResolver.ResolveTableName(type)); _typeTableNameCache.TryAdd(key, name); } LogReceived?.Invoke($"Resolved table name '{name}' for '{type}'"); return(name); }
/// <summary> /// Gets the the data column for the specified type, /// using the configured <see cref="IDataColumnResolver"/>. /// </summary> /// <param name="propertyInfo">The <see cref="NonaProperty"/> to get the data column for.</param> /// <returns>The data column for <paramref name="propertyInfo"/>.</returns> public static Tuple <string, Type> DataColumn(NonaProperty propertyInfo) { var key = propertyInfo.PropertyKey; if (!DataColumnCache.TryGetValue(key, out var column)) { column = _dataColumnResolver.ResolveDataColumn(propertyInfo); DataColumnCache.TryAdd(key, column); } LogReceived?.Invoke($"Resolved column name '{column.Item1}' for '{propertyInfo.PropertyInfo}'"); return(column); }
/// <summary> /// Gets the key property for the specified type, using the configured <see cref="IKeyPropertyResolver"/>. /// </summary> /// <param name="type">The <see cref="Type"/> to get the key property for.</param> /// <param name="isIdentity">A value indicating whether the key is an identity.</param> /// <returns>The key property for <paramref name="type"/>.</returns> public static PropertyInfo KeyProperty(Type type, out bool isIdentity) { if (!_typeKeyPropertyCache.TryGetValue(type, out var keyProperty)) { var propertyInfo = _keyPropertyResolver.ResolveKeyProperty(type, out isIdentity); keyProperty = new KeyPropertyInfo(propertyInfo, isIdentity); _typeKeyPropertyCache.TryAdd(type, keyProperty); } isIdentity = keyProperty.IsIdentity; LogReceived?.Invoke($"Resolved property '{keyProperty.PropertyInfo}' (Identity: {isIdentity}) as key property for '{type.Name}'"); return(keyProperty.PropertyInfo); }
/// <summary> /// Gets the key properties for the specified type, using the configured <see cref="IKeyPropertyResolver"/>. /// </summary> /// <param name="type">The <see cref="Type"/> to get the key properties for.</param> /// <param name="isIdentity">A value indicating whether the keys represent an identity.</param> /// <returns>The key properties for <paramref name="type"/>.</returns> public static PropertyInfo[] KeyProperties(Type type, out bool isIdentity) { if (!_typeKeyPropertiesCache.TryGetValue(type, out var keyPropertyInfo)) { var propertyInfos = _keyPropertyResolver.ResolveKeyProperties(type, out isIdentity); keyPropertyInfo = new KeyPropertyInfo(propertyInfos, isIdentity); _typeKeyPropertiesCache.TryAdd(type, keyPropertyInfo); } isIdentity = keyPropertyInfo.IsIdentity; LogReceived?.Invoke($"Resolved property '{string.Join<PropertyInfo>(", ", keyPropertyInfo.PropertyInfos)}' (Identity: {isIdentity}) as key property for '{type}'"); return(keyPropertyInfo.PropertyInfos); }
/// <summary> /// Gets the key property for the specified type, using the configured <see cref="IKeyPropertyResolver"/>. /// </summary> /// <param name="type">The <see cref="Type"/> to get the key property for.</param> /// <param name="isIdentity">A value indicating whether the key is an identity.</param> /// <returns>The key property for <paramref name="type"/>.</returns> public static NonaProperty KeyProperty(Type type, out bool isIdentity) { if (!TypeKeyPropertyCache.TryGetValue(type.TypeHandle, out var keyProperty)) { var NonaProperty = _keyPropertyResolver.Resolve(type, out isIdentity); keyProperty = new KeyPropertyInfo(NonaProperty, isIdentity); TypeKeyPropertyCache.TryAdd(type.TypeHandle, keyProperty); } isIdentity = keyProperty.IsIdentity; LogReceived?.Invoke($"Resolved property '{keyProperty.NonaProperty}' (Identity: {isIdentity}) as key property for '{type.Name}'"); return(keyProperty.NonaProperty); }
/// <summary> /// Gets the name of the table in the database for the specified type, /// using the configured <see cref="ITableNameResolver"/>. /// </summary> /// <param name="type">The <see cref="Type"/> to get the table name for.</param> /// <returns>The table name in the database for <paramref name="type"/>.</returns> public static string Table(Type type) { if (!_typeTableNameCache.TryGetValue(type, out var name)) { name = _tableNameResolver.ResolveTableName(type); if (EscapeCharacterStart != char.MinValue || EscapeCharacterEnd != char.MinValue) { name = EscapeCharacterStart + name + EscapeCharacterEnd; } _typeTableNameCache.TryAdd(type, name); } LogReceived?.Invoke($"Resolved table name '{name}' for '{type.Name}'"); return(name); }
/// <summary> /// Indicates a new log entry has been received and that the log provider should handle it. /// </summary> /// <param name="logEntry"> /// The log entry to handle. /// </param> public void AddLogEntry(LogEntry logEntry) { if (!_supportedLogLevels.Contains(logEntry.Level)) { return; } try { LogReceived?.Invoke(null, new LogEventArgs(logEntry)); } catch { // Don't let logging bring us down so swallow the error } }
private async void Connect() { try { if (messageWebSocket == null) { messageWebSocket = new MessageWebSocket(); messageWebSocket.Control.MessageType = SocketMessageType.Utf8; messageWebSocket.MessageReceived += (sender, args) => { using (DataReader reader = args.GetDataReader()) { reader.UnicodeEncoding = UnicodeEncoding.Utf8; try { string read = reader.ReadString(reader.UnconsumedBufferLength); var response = PlayerResponse.ToObject(read); StatusReceived?.Invoke(response); } catch (Exception ex) { LogReceived?.Invoke(ex.Message); } } }; messageWebSocket.Closed += (sender, args) => { _websocketConnected = false; ConnectionChanged?.Invoke(_websocketConnected); }; } await messageWebSocket.ConnectAsync(new Uri(WebsocketUrl)); messageWriter = new DataWriter(messageWebSocket.OutputStream); _websocketConnected = true; ConnectionChanged?.Invoke(_websocketConnected); AddRegister(_registered); } catch (Exception) { _websocketConnected = false; ConnectionChanged?.Invoke(_websocketConnected); await Task.CompletedTask; } }
/// <summary> /// Gets the name of the column in the database for the specified type, /// using the configured <see cref="IColumnNameResolver"/>. /// </summary> /// <param name="propertyInfo">The <see cref="NonaProperty"/> to get the column name for.</param> /// <returns>The column name in the database for <paramref name="propertyInfo"/>.</returns> public static string Column(NonaProperty propertyInfo) { var key = propertyInfo.PropertyKey; if (!ColumnNameCache.TryGetValue(key, out var columnName)) { columnName = _columnNameResolver.Resolve(propertyInfo); if (EscapeCharacterStart != char.MinValue || EscapeCharacterEnd != char.MinValue) { columnName = EscapeCharacterStart + columnName + EscapeCharacterEnd; } ColumnNameCache.TryAdd(key, columnName); } LogReceived?.Invoke($"Resolved column name '{columnName}' for '{propertyInfo.PropertyInfo}'"); return(columnName); }
/// <summary> /// Gets the name of the column in the database for the specified type, /// using the configured <see cref="IColumnNameResolver"/>. /// </summary> /// <param name="propertyInfo">The <see cref="PropertyInfo"/> to get the column name for.</param> /// <returns>The column name in the database for <paramref name="propertyInfo"/>.</returns> public static string Column(PropertyInfo propertyInfo) { var key = $"{propertyInfo.DeclaringType}.{propertyInfo.Name}"; if (!_columnNameCache.TryGetValue(key, out var columnName)) { columnName = _columnNameResolver.ResolveColumnName(propertyInfo); if (EscapeCharacterStart != char.MinValue || EscapeCharacterEnd != char.MinValue) { columnName = EscapeCharacterStart + columnName + EscapeCharacterEnd; } _columnNameCache.TryAdd(key, columnName); } LogReceived?.Invoke($"Resolved column name '{columnName}' for '{propertyInfo.Name}'"); return(columnName); }
private void ProcessBuffer(CancellationToken token) { LogEntry entry; while (!token.IsCancellationRequested) { try { entry = lcs.ReadLogEntry(); } catch (IOException) { return; } LogReceived?.Invoke(this, entry); } }
protected virtual void Dispose(bool disposing) { if (_disposed) { return; } if (disposing) { LogReceived.Dispose(); ReceiveDataInvoked.Dispose(); ReceiveDataCompleted.Dispose(); ReceiveStreamInvoked.Dispose(); ReceiveStreamCompleted.Dispose(); } _disposed = true; }
private void Send() { #if NETFX_CORE try { if (!_websocketConnected) { return; } var req = GetActiveRequest(); var jsonStr = req.ToJsonObject().Stringify(); LogReceived?.Invoke("Send() " + jsonStr); messageWriter.WriteString(jsonStr); messageWriter.StoreAsync(); _activeRequest = null; } catch (Exception e) { LogReceived?.Invoke("Send() " + e.Message); } #else try { if (!_websocketConnected) { Console.Write("not connected.\n"); return; } var msg = JSON.ToJSON(GetActiveRequest(), DEFAULT_PARAM); Debug.WriteLine("Send() String " + msg); _webSocket.SendAsync(msg, b => { _activeRequest = null; }); } catch (Exception e) { Console.Write($"{e.Message} {e}\n"); } #endif }
/// <summary> /// Gets the foreign key property for the specified source type and including type /// using the configured <see cref="IForeignKeyPropertyResolver"/>. /// </summary> /// <param name="sourceType">The source type which should contain the foreign key property.</param> /// <param name="includingType">The type of the foreign key relation.</param> /// <param name="foreignKeyRelation">The foreign key relationship type.</param> /// <returns>The foreign key property for <paramref name="sourceType"/> and <paramref name="includingType"/>.</returns> public static PropertyInfo ForeignKeyProperty(Type sourceType, Type includingType, out ForeignKeyRelation foreignKeyRelation) { var key = $"{sourceType};{includingType}"; if (!_typeForeignKeyPropertyCache.TryGetValue(key, out var foreignKeyInfo)) { // Resolve the property and relation. var foreignKeyProperty = _foreignKeyPropertyResolver.ResolveForeignKeyProperty(sourceType, includingType, out foreignKeyRelation); // Cache the info. foreignKeyInfo = new ForeignKeyInfo(foreignKeyProperty, foreignKeyRelation); _typeForeignKeyPropertyCache.TryAdd(key, foreignKeyInfo); } foreignKeyRelation = foreignKeyInfo.Relation; LogReceived?.Invoke($"Resolved property '{foreignKeyInfo.PropertyInfo}' ({foreignKeyInfo.Relation}) as foreign key between '{sourceType}' and '{includingType}'"); return(foreignKeyInfo.PropertyInfo); }
public void Dispose() { #if NETFX_CORE if (messageWriter != null) { // In order to reuse the socket with another DataWriter, the socket's output stream needs to be detached. // Otherwise, the DataWriter's destructor will automatically close the stream and all subsequent I/O operations // invoked on the socket's output stream will fail with ObjectDisposedException. // // This is only added for completeness, as this sample closes the socket in the very next code block. messageWriter.DetachStream(); messageWriter.Dispose(); messageWriter = null; } if (messageWebSocket != null) { try { messageWebSocket.Close(1000, "Closed due to user request."); } catch (Exception ex) { LogReceived?.Invoke(ex.Message); } } #else try { _webSocket.CloseAsync(); } catch (Exception e) { Console.WriteLine(e); } #endif }
public void ReceiveLog(List <string> log) { ServerLog = log; LogReceived.Set(); }