public LogMessage(string text, DateTime timestamp, string sourceInfo, LogMessageType type)
{
this.text = text;
this.timestamp = timestamp;
this.sourceInfo = sourceInfo;
this.type = type;
}
/// <summary>
/// Write Log By MessageType
/// </summary>
/// <param name="message">Message</param>
/// <param name="messageType">MessageType</param>
/// <param name="ex">Exception Object</param>
/// <param name="type">Log Source Type</param>
private static void DoLog(string message, LogMessageType messageType, Exception ex, Type type)
{
string stackTrace = string.Empty;
if (ex != null)
{
stackTrace = ex.StackTrace;
}
_mLog = LogManager.GetLogger(type);
switch (messageType)
{
case LogMessageType.Debug:
//AppLog._mLog.Debug(message + " ExceptionStackTrace:" + stackTrace, ex);//Edit by Gerry
AppLog._mLog.Debug(message + stackTrace, ex);
break;
case LogMessageType.Info:
AppLog._mLog.Info(message + stackTrace, ex);
break;
case LogMessageType.Warn:
AppLog._mLog.Warn(message + stackTrace, ex);
break;
case LogMessageType.Error:
AppLog._mLog.Error(message + stackTrace, ex);
break;
case LogMessageType.Fatal:
AppLog._mLog.Fatal(message + stackTrace, ex);
break;
}
}
/// <summary>
/// Initializes a new instance of the <see cref="LogMessage"/> class.
/// </summary>
/// <param name="content">
/// The content.
/// </param>
/// <param name="messageType">
/// The message type.
/// </param>
/// <param name="logLevel">
/// The log level.
/// </param>
/// <param name="messageIndex">
/// The message Index.
/// </param>
public LogMessage(string content, LogMessageType messageType, LogLevel logLevel, long messageIndex)
{
this.Content = content;
this.MessageType = messageType;
this.LogLevel = logLevel;
this.MessageIndex = messageIndex;
}
public LogMessage(String message, LogMessageType type, LogMessageSeverity severity, Exception exception)
{
Message = message;
Type = type;
Severity = severity;
Exception = exception;
}
/// <summary>
/// Writes a single message to the output.
/// </summary>
/// <param name="source">The <see cref="Log"/> from which the message originates.</param>
/// <param name="type">The type of the log message.</param>
/// <param name="msg">The message to write.</param>
/// <param name="context">The context in which this log was written. Usually the primary object the log entry is associated with.</param>
public virtual void Write(Log source, LogMessageType type, string msg, object context)
{
int indent = source.Indent;
string prefix = source.Prefix ?? "";
string[] lines = msg.Split(new[] { '\n', '\r', '\0' }, StringSplitOptions.RemoveEmptyEntries);
for (int i = 0; i < lines.Length; i++)
{
if (i == 0)
{
switch (type)
{
case LogMessageType.Message:
lines[i] = prefix + "Msg: " + new string(' ', indent * 2) + lines[i];
break;
case LogMessageType.Warning:
lines[i] = prefix + "Wrn: " + new string(' ', indent * 2) + lines[i];
break;
case LogMessageType.Error:
lines[i] = prefix + "ERR: " + new string(' ', indent * 2) + lines[i];
break;
}
}
else
{
lines[i] = new string(' ', prefix.Length + 5 + indent * 2) + lines[i];
}
this.WriteLine(source, type, lines[i], context);
}
}
// Help methods that use our FileSystem abstraction
public override void AppendLog(String message, LogMessageType messageType)
{
string textEntry = string.Format("{0:MM-dd-yyyy HH:mm:ss:ffff} :{1}: [{2}] {3}", DateTime.Now, System.Threading.Thread.CurrentThread.ManagedThreadId, messageType.ToString(), message);
switch (messageType)
{
case LogMessageType.Info:
Android.Util.Log.Info(TAG, message);
break;
case LogMessageType.Warn:
Android.Util.Log.Debug(TAG, message);
break;
case LogMessageType.Debug:
Android.Util.Log.Debug(TAG, message);
break;
case LogMessageType.Error:
Android.Util.Log.Error(TAG, message);
break;
case LogMessageType.Fatal:
Android.Util.Log.Wtf(TAG, message);
break;
case LogMessageType.Metric:
Android.Util.Log.Debug( TAG_METRIC, message );
break;
default:
break;
}
AppendText(LogFileName, textEntry);
}
void Colorize ( LogMessageType eventType )
{
switch (eventType) {
case LogMessageType.Debug :
Console.ForegroundColor = ConsoleColor.DarkGreen;
Console.BackgroundColor = ConsoleColor.Black;
break;
case LogMessageType.Verbose :
Console.ForegroundColor = ConsoleColor.DarkGray;
Console.BackgroundColor = ConsoleColor.Black;
break;
case LogMessageType.Information :
Console.ForegroundColor = ConsoleColor.Gray;
Console.BackgroundColor = ConsoleColor.Black;
break;
case LogMessageType.Warning :
Console.ForegroundColor = ConsoleColor.Yellow;
Console.BackgroundColor = ConsoleColor.Black;
break;
case LogMessageType.Error :
Console.ForegroundColor = ConsoleColor.Red;
Console.BackgroundColor = ConsoleColor.Black;
break;
case LogMessageType.Fatal :
Console.ForegroundColor = ConsoleColor.Yellow;
Console.BackgroundColor = ConsoleColor.Red;
break;
}
}
/// <summary>
/// Writes a single message to the output.
/// </summary>
/// <param name="source">The <see cref="Log"/> from which the message originates.</param>
/// <param name="type">The type of the log message.</param>
/// <param name="msg">The message to write.</param>
/// <param name="context">The context in which this log was written. Usually the primary object the log entry is associated with.</param>
public virtual void Write(Log source, LogMessageType type, string msg, object context)
{
int indent = source.Indent;
string[] lines = msg.Split(new[] { '\n', '\r' }, StringSplitOptions.RemoveEmptyEntries);
for (int i = 0; i < lines.Length; i++)
{
if (i == 0)
{
switch (type)
{
case LogMessageType.Message:
lines[i] = source.Prefix + "Info: " + new string(' ', indent * 4) + lines[i];
break;
case LogMessageType.Warning:
lines[i] = source.Prefix + "Warning: " + new string(' ', indent * 4) + lines[i];
break;
case LogMessageType.Error:
lines[i] = source.Prefix + "ERROR: " + new string(' ', indent * 4) + lines[i];
break;
}
}
else
{
lines[i] = source.Prefix + " " + new string(' ', indent * 4) + lines[i];
}
this.writer.WriteLine(lines[i]);
}
}
public void WriteLineTest1()
{
LogMessageType messageFlag = new LogMessageType(); // TODO: 初始化为适当的值
string strFormat = string.Empty; // TODO: 初始化为适当的值
object[] arg = null; // TODO: 初始化为适当的值
LOGs.WriteLine( messageFlag, strFormat, arg );
Assert.Inconclusive( "无法验证不返回值的方法。" );
}
public override void WriteMessage(string message, LogMessageType type, Exception exception)
{
if (type == LogMessageType.Error)
System.Threading.Interlocked.Increment(ref ErrorCount);
else if (type == LogMessageType.Warning)
System.Threading.Interlocked.Increment(ref WarningCount);
base.WriteMessage(this.Backupset + ", " + message, type, exception);
}
/// <summary>
/// Initializes a new instance of the <see cref="AssetLogMessage" /> class.
/// </summary>
/// <param name="package">The package.</param>
/// <param name="assetReference">The asset reference.</param>
/// <param name="type">The type.</param>
/// <param name="messageCode">The message code.</param>
/// <param name="arguments">The arguments.</param>
/// <exception cref="System.ArgumentNullException">asset</exception>
public AssetLogMessage(Package package, IReference assetReference, LogMessageType type, string text)
{
this.package = package;
AssetReference = assetReference;
Type = type;
Related = new List<IReference>();
Text = text;
}
TextWriter GetWriter ( LogMessageType eventType )
{
if ( eventType==LogMessageType.Error || eventType==LogMessageType.Warning || eventType==LogMessageType.Fatal ) {
return Console.Error;
} else {
return Console.Out;
}
}
/// <summary>
/// Initializes a new instance of the <see cref="LogMessage" /> class.
/// </summary>
/// <param name="module">The module.</param>
/// <param name="type">The type.</param>
/// <param name="text">The text.</param>
/// <param name="exception">The exception.</param>
/// <param name="callerInfo">The caller info.</param>
public LogMessage(string module, LogMessageType type, string text, Exception exception, CallerInfo callerInfo)
{
Module = module;
Type = type;
Text = text;
Exception = exception;
CallerInfo = callerInfo;
}
// Help methods that use our FileSystem abstraction
public override void AppendLog(String message, LogMessageType messageType)
{
string textEntry = string.Format("{0:MM-dd-yyyy HH:mm:ss:ffff} :{1}: [{2}] {3}", DateTime.Now, System.Threading.Thread.CurrentThread.ManagedThreadId, messageType.ToString(), message);
Console.WriteLine(textEntry);
AppendText(LogFileName, textEntry);
}
/// <summary>
/// Activates the log for loggers that match a regex pattern on the module name.
/// </summary>
/// <param name="regexPatternModule">The regex pattern to match a module name.</param>
/// <param name="minimumLevel">The minimum level.</param>
/// <param name="maximumLevel">The maximum level.</param>
/// <param name="enabledFlag">if set to <c>true</c> enaable the log, else disable.</param>
/// <exception cref="ArgumentNullException">If regexPatternModule is null</exception>
public static void ActivateLog(string regexPatternModule, LogMessageType minimumLevel, LogMessageType maximumLevel = LogMessageType.Fatal, bool enabledFlag = true)
{
if (regexPatternModule == null)
throw new ArgumentNullException("regexPatternModule");
var regex = new Regex(regexPatternModule);
ActivateLog(regex, minimumLevel, maximumLevel);
}
public LogMessageEventArgs(LogMessageType logMessageType, string message)
{
if (message == null)
throw new ArgumentNullException("message");
LogMessageType = logMessageType;
Message = message;
}
/// <summary>
///
/// </summary>
/// <param name="messageFlag"></param>
/// <param name="strFormat"></param>
/// <param name="parameter"></param>
public LogInfo(LogMessageType messageFlag, string strFormat, object[] parameter = null)
{
m_messageFlag = messageFlag;
format = strFormat;
_parameter = parameter;
outStr = null;
time = DateTime.Now;
}
/// <summary>
/// The function called when a message is logged
/// </summary>
/// <param name="message">The message logged</param>
/// <param name="type">The type of message logged</param>
/// <param name="exception">An exception, may be null</param>
public virtual void WriteMessage(string message, LogMessageType type, Exception exception)
{
m_stream.WriteLine("{0:u} - {1}: {2}", DateTime.Now, type, message);
if (exception != null)
{
m_stream.WriteLine(exception.ToString());
m_stream.WriteLine();
}
}
/// <summary>
/// Initializes a new instance of the <see cref="SerializableLogMessage"/> class using the given parameters to set its properties.
/// </summary>
/// <param name="module">The module name.</param>
/// <param name="type">The type.</param>
/// <param name="text">The text.</param>
/// <param name="exceptionInfo">The exception information. This parameter can be null.</param>
public SerializableLogMessage(string module, LogMessageType type, string text, ExceptionInfo exceptionInfo = null)
{
if (module == null) throw new ArgumentNullException("module");
if (text == null) throw new ArgumentNullException("text");
Module = module;
Type = type;
Text = text;
ExceptionInfo = exceptionInfo;
}
/// <summary>
/// Initializes a new instance of the <see cref="AssetLogMessage" /> class.
/// </summary>
/// <param name="package">The package.</param>
/// <param name="assetReference">The asset reference.</param>
/// <param name="type">The type.</param>
/// <param name="messageCode">The message code.</param>
/// <exception cref="System.ArgumentNullException">asset</exception>
public AssetLogMessage(Package package, IReference assetReference, LogMessageType type, AssetMessageCode messageCode)
{
this.package = package;
AssetReference = assetReference;
Type = type;
MessageCode = messageCode;
Related = new List<IReference>();
Text = AssetMessageStrings.ResourceManager.GetString(messageCode.ToString()) ?? messageCode.ToString();
}
public LogEntry(Log source, LogMessageType type, string msg)
{
this.source = source;
this.type = type;
this.msg = msg;
this.indent = source.Indent;
this.timestamp = DateTime.Now;
this.frameIndex = Time.FrameCount;
}
private void SetDarkConsoleColor(LogMessageType type)
{
switch (type)
{
default:
case LogMessageType.Message: Console.ForegroundColor = ConsoleColor.DarkGray; break;
case LogMessageType.Warning: Console.ForegroundColor = ConsoleColor.DarkYellow; break;
case LogMessageType.Error: Console.ForegroundColor = ConsoleColor.DarkRed; break;
}
}
public LogEntry(Log source, LogMessageType type, string msg, object context)
{
this.source = source;
this.type = type;
this.message = msg;
this.context = context;
this.indent = source.Indent;
this.timeStamp = DateTime.Now;
this.frameStamp = Time.FrameCount;
}
public override void Log(LogMessageType type, bool logToConsole, string message)
{
if (_entries != null)
{
LogEntry entry = new LogEntry(message, type, logToConsole);
_entriesLock.WaitOne();
_entries.Add(entry);
_entriesLock.ReleaseMutex();
}
}
/// <summary>
/// Initializes a new instance of the <see cref="AssetLogMessage" /> class.
/// </summary>
/// <param name="package">The package.</param>
/// <param name="assetReference">The asset reference.</param>
/// <param name="type">The type.</param>
/// <param name="messageCode">The message code.</param>
/// <param name="arguments">The arguments.</param>
/// <exception cref="System.ArgumentNullException">asset</exception>
public AssetLogMessage(Package package, IReference assetReference, LogMessageType type, AssetMessageCode messageCode, params object[] arguments)
{
this.package = package;
AssetReference = assetReference;
Type = type;
MessageCode = messageCode;
Related = new List<IReference>();
var message = AssetMessageStrings.ResourceManager.GetString(messageCode.ToString()) ?? messageCode.ToString();
Text = string.Format(message, arguments);
}
public bool Log(string userID, string userName, string messageString, LogMessageType messageType)
{
var log = new Log();
log.UserID = userID;
log.UserName = userName;
log.Message = messageString;
logRepository.Create(log);
return true;
}
public void OutputLog(string message, LogMessageType logType)
{
if (!supportedLogTypes.Contains(logType))
{
return;
}
foreach (var logger in innerLoggers)
{
logger.Process(message, logType);
}
}
private void SetBrightConsoleColor(LogMessageType type, bool highlight)
{
switch (type)
{
default:
case LogMessageType.Message: Console.ForegroundColor = highlight ?
ConsoleColor.White :
ConsoleColor.Gray; break;
case LogMessageType.Warning: Console.ForegroundColor = ConsoleColor.Yellow; break;
case LogMessageType.Error: Console.ForegroundColor = ConsoleColor.Red; break;
}
}
public LogItem()
{
LogItemId = LogHolder.Singleton.NextId;
ClientId = 0;
EntityId = 0;
EntityMessageType = EntityMessage.Null;
ComponentFamily = ComponentFamily.Generic;
SenderType = "";
MessageType = ComponentMessageType.Null;
Parameters = null;
MessageSource = LogMessageType.None;
}
///// <summary>
///// Indicates that debug messages are allowed.
///// </summary>
//public static bool IsDebugMessageEnabled { get { return VerbosityLevel == LogMessageType.Debug; } }
/// <summary>
///
/// </summary>
/// <param name="type"></param>
/// <param name="message"></param>
static void AddMessage ( LogMessageType type, string text )
{
if (type>=VerbosityLevel) {
lock (lockObj) {
var threadId = Thread.CurrentThread.ManagedThreadId;
var message = new LogMessage( threadId, type, text );
foreach (var listener in listeners) {
listener.Log( message );
}
}
}
}
/// <summary>
/// Writes a log message in the log
/// </summary>
/// <param name="message">The message to write to log</param>
/// <param name="messageType">The type of the log message to write</param>
/// <param name="type">The object type for which to get the logger for writing the log</param>
public static void Write(string message, LogMessageType messageType, Type type)
{
DoLog(message, messageType, null, type);
}
/// <summary>
/// Writes a log message in the log
/// </summary>
/// <param name="message">The message to write to log</param>
/// <param name="messageType">The type of the log message to write</param>
public static void Write(string message, LogMessageType messageType)
{
DoLog(message, messageType, null, Type.GetType("System.Object"));
}
/// <summary>
/// Activates the log for loggers that match a regex pattern on the module name.
/// </summary>
/// <param name="regexPatternModule">The regex pattern to match a module name.</param>
/// <param name="minimumLevel">The minimum level.</param>
/// <param name="maximumLevel">The maximum level.</param>
/// <param name="enabledFlag">if set to <c>true</c> enaable the log, else disable.</param>
/// <exception cref="ArgumentNullException">If regexPatternModule is null</exception>
public static void ActivateLog(string regexPatternModule, LogMessageType minimumLevel, LogMessageType maximumLevel = LogMessageType.Fatal, bool enabledFlag = true)
{
if (regexPatternModule == null)
{
throw new ArgumentNullException("regexPatternModule");
}
var regex = new Regex(regexPatternModule);
ActivateLog(regex, minimumLevel, maximumLevel);
}
public void Log(string loggerName, object message, Exception exception, LogMessageType logMessageType)
{
Debug.WriteLine($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")} {message}: {exception}");
}
public void Log(Type senderType, object message, LogMessageType logMessageType)
{
}
/// <summary>
/// Determines whether the <see cref="LogMessageType"/> is enabled (see <see cref="EnabledLogMessageTypes"/>).
/// </summary>
/// <param name="type">The <see cref="LogMessageType"/>.</param>
/// <returns><c>true</c> if enabled; otherwise, <c>false</c>.</returns>
public static bool IsEnabled(LogMessageType type)
{
return((EnabledLogMessageTypes & type) == type);
}
private HightligtedTextPart[] GetHightlightedTextParts(string message, LogMessageType type)
{
HightligtedTextPart currentPart = null;
var parts = new List <HightligtedTextPart>();
var lastColor = ConsoleColor.White;
var isInsideString = false;
var isInsideQuoute = false;
var isInsideParanthesis = false;
for (var i = 0; i < message.Length; i++)
{
var token = GetToken(message, i, isInsideString, isInsideParanthesis, isInsideQuoute);
if (token == null)
{
continue;
}
var color = token.Color;
if (token.IsQuouteStart)
{
isInsideQuoute = true;
}
if (token.IsQuouteEnd)
{
isInsideQuoute = false;
}
if (token.IsStringStart)
{
isInsideString = true;
}
if (token.IsStringEnd)
{
isInsideString = false;
}
if (token.IsParanthesisStart)
{
isInsideParanthesis = true;
}
if (token.IsParanthesisEnd)
{
isInsideParanthesis = false;
}
if (token.IsLineBreak)
{
if (currentPart != null)
{
parts.Add(currentPart);
parts.Add(new HightligtedTextPart {
IsLineBreak = true
});
currentPart = null;
lastColor = color;
continue;
}
}
if (currentPart == null)
{
currentPart = new HightligtedTextPart();
currentPart.Text += token.Text;
currentPart.Color = color;
lastColor = color;
}
else if (lastColor == color)
{
currentPart.Text += token.Text;
if (i >= message.Length - 1)
{
parts.Add(currentPart);
break;
}
}
if (lastColor != color)
{
parts.Add(currentPart);
currentPart = new HightligtedTextPart();
currentPart.Text += token.Text;
currentPart.Color = color;
lastColor = color;
}
}
switch (type)
{
case LogMessageType.Error:
for (var i = 3; i < parts.Count; i++)
{
parts[i].Color = ErrorColor;
}
break;
case LogMessageType.Warning:
for (var i = 3; i < parts.Count; i++)
{
parts[i].Color = WarningColor;
}
break;
case LogMessageType.Debug:
for (var i = 3; i < parts.Count; i++)
{
parts[i].Color = DebugColor;
}
break;
}
return(parts.ToArray());
}
public AssetSerializableLogMessage(AssetId assetId, UFile assetUrl, LogMessageType type, string text, ExceptionInfo exceptionInfo = null)
: base("", type, text, exceptionInfo)
{
AssetId = assetId;
AssetUrl = assetUrl;
}
/// <summary>
/// Logs messages to a database.
/// </summary>
/// <param name="authenticatedTicket">The ticket which has the ticket string. The ticket could also be not authenticated if an error happened.</param>
/// <param name="messageType">Type of message.</param>
/// <param name="direction">Direction of the message (In the WebService, or Out the WebService).</param>
/// <param name="ticket">The ticket.</param>
/// <param name="arguments">Other arguments to save.</param>
protected internal virtual void LogMessage(IAuthenticatedTicket authenticatedTicket, LogMessageType messageType, LogDirection direction, string ticket, params string[] arguments)
{
logger.LogTrace("Ticket: {TICKET}; Type: {TYPE}; Direction: {DIRECTION}; Arguments: {Arguments}", ticket, messageType, direction, arguments);
}
/// <summary>
/// 防止多线程的问题
/// </summary>
/// <param name="messageFlag"></param>
/// <param name="strFormat"></param>
private static void WriteLine(LogMessageType messageFlag, string strFormat)
{
WriteLine(messageFlag, strFormat, null);
}
// сообщения для лога
/// <summary>
/// добавить в лог новое сообщение
/// </summary>
private void SendLogMessage(string message, LogMessageType type)
{
LogMessageEvent?.Invoke(message, type);
}
/// <summary>
/// Writes a log message in the log
/// </summary>
/// <param name="message">The message to write to log</param>
/// <param name="messageType">The type of the log message to write</param>
/// <param name="ex">Exception to be logged</param>
public static void Write(string message, LogMessageType messageType, Exception ex)
{
DoLog(message, messageType, ex, Type.GetType("System.Object"));
}
/// <summary>
/// Writes a log message in the log
/// </summary>
/// <param name="message">The message to write to log</param>
/// <param name="messageType">The type of the log message to write</param>
/// <param name="ex">Exception to be logged</param>
/// <param name="type">The object type for which to get the logger for writing the log</param>
public static void Write(string message, LogMessageType messageType, Exception ex, Type type)
{
DoLog(message, messageType, ex, type);
}
/// <summary>
/// Logs messages to a database.
/// </summary>
/// <param name="authenticatedTicket">The ticket which has the ticket string. The ticket could also be not authenticated if an error happened.</param>
/// <param name="messageType">Type of message.</param>
/// <param name="direction">Direction of the message (In the WebService, or Out the WebService).</param>
/// <param name="arguments">Other arguments to save.</param>
protected internal virtual void LogMessage(AuthenticatedTicket authenticatedTicket, LogMessageType messageType, LogDirection direction, string ticket, params string[] arguments)
{
}
/// <summary>
/// Writes message line to text log file. Type of message is also specified.
/// </summary>
/// <param name="message"></param>
/// <param name="logMessageType"></param>
public void WriteLine(string message, LogMessageType logMessageType)
{
string messageDateAndType = "";
string formattedMessage = "";
string messagePrefix = "";
string machineName = "";
try
{
if (this._showDatetime)
{
messageDateAndType = DateTime.Now.ToString(this._dateTimeFormat);
}
else
{
messageDateAndType = "";
}
if (this._showMessageType)
{
if (messageDateAndType.Length > 0)
{
messageDateAndType += " ";
}
messageDateAndType += logMessageType.ToString().ToUpper() + ": ";
}
if (this.ShowErrorWarningTypes == true && this.ShowMessageType == false)
{
if (logMessageType == LogMessageType.Warning || logMessageType == LogMessageType.Error)
{
if (messageDateAndType.Length > 0)
{
messageDateAndType += " ";
}
messageDateAndType += logMessageType.ToString().ToUpper() + ": ";
}
}
if (this._machineName.Length > 0)
{
if (this._applicationName.Length > 0)
{
machineName = " on " + this._machineName;
}
else
{
machineName = this._machineName;
}
}
else
{
machineName = "";
}
if ((this._applicationName.Length > 0) | (machineName.Length > 0))
{
messagePrefix = (messageDateAndType + " <" + (this._applicationName + machineName).Trim() + "> ").Trim();
}
else
{
messagePrefix = messageDateAndType.Trim();
}
if (messagePrefix.Length > 0)
{
formattedMessage = messagePrefix + " " + message;
}
else
{
formattedMessage = message;
}
StreamWriter writer = File.AppendText(this._fileName);
writer.WriteLine(formattedMessage);
writer.Flush();
writer.Close();
}
catch (Exception ex)
{
throw ex;
}
}
public MutationRunProgress(string message, int progress, LogMessageType logMessageType)
{
Progress = progress;
LogMessageType = logMessageType;
Message = message;
}
/// <summary>
/// Writes a message to the current log destination
/// </summary>
/// <param name="message">The message to write</param>
/// <param name="type">The type of the message</param>
public static void WriteMessage(string message, LogMessageType type)
{
WriteMessage(message, type, null);
}
/// <summary>
/// Конструктор с выбором типа сообщения.
/// </summary>
/// <param name="message">Текст сообщения</param>
/// <param name="type">Тип сообщения</param>
public LogMessage(string message, LogMessageType type = LogMessageType.Notification)
{
Message = message;
Type = type;
}
public void Log(Type senderType, object message, Exception exception, LogMessageType logMessageType)
{
}
public void Write <T>(T entity, LogMessageType messageType)
{
Write(entity, messageType, null, null);
}
public override void DoWindowContents(Rect rect)
{
int btnWidth = 200;
Rect chkEnabledRect = new Rect(x: 0, y: 20f, width: rect.width, height: controlHeight);
Rect teSearchRect = new Rect(x: 0, y: chkEnabledRect.yMax, width: rect.width, height: controlHeight);
Rect btnErrorsRect = new Rect(x: 10f, y: teSearchRect.yMax, width: btnWidth, height: controlHeight);
Rect btnWarningsRect = new Rect(x: btnErrorsRect.xMax, y: btnErrorsRect.y, width: btnWidth, height: controlHeight);
Rect btnMessagesRect = new Rect(x: btnWarningsRect.xMax, y: btnErrorsRect.y, width: btnWidth, height: controlHeight);
Rect teContainFilterRect = new Rect(x: 0, y: btnMessagesRect.yMax, width: rect.width, height: controlHeight);
bool enabled = Settings.Get().LogFilter.enabled;
Widgets.CheckboxLabeled(chkEnabledRect, "AnotherTweaks.LogFilter.Enabled".Translate(), ref enabled);
Settings.Get().LogFilter.enabled = enabled;
_searchBuf = Widgets.TextEntryLabeled(teSearchRect, "AnotherTweaks.LogFilter.Search".Translate(), _searchBuf);
Color color = GUI.color;
if (_logMessageType == LogMessageType.Error)
{
GUI.color = SelectedColor;
}
if (Widgets.ButtonText(btnErrorsRect, "AnotherTweaks.LogFilter.ErrorsTab".Translate()))
{
_logMessageType = LogMessageType.Error;
}
GUI.color = color;
if (_logMessageType == LogMessageType.Warning)
{
GUI.color = SelectedColor;
}
if (Widgets.ButtonText(btnWarningsRect, "AnotherTweaks.LogFilter.WarningsTab".Translate()))
{
_logMessageType = LogMessageType.Warning;
}
GUI.color = color;
if (_logMessageType == LogMessageType.Message)
{
GUI.color = SelectedColor;
}
if (Widgets.ButtonText(btnMessagesRect, "AnotherTweaks.LogFilter.MessagesTab".Translate()))
{
_logMessageType = LogMessageType.Message;
}
GUI.color = color;
var cfg = Settings.Get().LogFilter;
IEnumerable <LogMessageHided> containFilteredItems = null;
switch (_logMessageType)
{
case LogMessageType.Error:
cfg.errorContain = Widgets.TextEntryLabeled(teContainFilterRect, "AnotherTweaks.LogFilter.ErrorContain".Translate(), cfg.errorContain);
containFilteredItems = _logMessages.Where(x => x.type == _logMessageType && !cfg.errorContain.ContainFilter(x.text));
break;
case LogMessageType.Warning:
cfg.warningContain = Widgets.TextEntryLabeled(teContainFilterRect, "AnotherTweaks.LogFilter.WarningContain".Translate(), cfg.warningContain);
containFilteredItems = _logMessages.Where(x => x.type == _logMessageType && !cfg.warningContain.ContainFilter(x.text));
break;
case LogMessageType.Message:
cfg.messageContain = Widgets.TextEntryLabeled(teContainFilterRect, "AnotherTweaks.LogFilter.MessageContain".Translate(), cfg.messageContain);
containFilteredItems = _logMessages.Where(x => x.type == _logMessageType && !cfg.messageContain.ContainFilter(x.text));
break;
}
List <LogMessageHided> drawItems;
if (String.IsNullOrWhiteSpace(_searchBuf))
{
drawItems = containFilteredItems.ToList();
}
else
{
drawItems = containFilteredItems.Where(x => x.text.ToLower().Contains(_searchBuf.ToLower())).ToList();
}
float y = teContainFilterRect.yMax;
Rect outRect = new Rect(x: 0f, y: y, width: rect.width, height: rect.height - y);
Rect viewRect = new Rect(x: 0f, y: y, width: rect.width - 30f, height: drawItems.Count * controlHeight);
Widgets.BeginScrollView(outRect: outRect, scrollPosition: ref _scrollPosition, viewRect: viewRect);
foreach (var item in drawItems)
{
Rect chkItemRect = new Rect(x: 0, y: y, width: viewRect.width, height: controlHeight);
Widgets.CheckboxLabeled(chkItemRect, item.text, ref item.show);
TooltipHandler.TipRegion(chkItemRect, item.text);
Widgets.DrawHighlightIfMouseover(chkItemRect);
y += controlHeight /*chkItemRect.yMax*/;
}
Widgets.EndScrollView();
}
public void Log(string Message, int MessageId, LogMessageType MessageType = LogMessageType.Information,
LogReceiver Receiver = LogReceiver.MessageBox | LogReceiver.Console, string Details = null)
{
string timeStamp = DateTime.Now.ToString();
if (Receiver.HasFlag(LogReceiver.Console))
{
ListViewItem logItem = new ListViewItem();
string iconName = null;
string levelName = null;
_detailsList.Add(Details);
switch (MessageType)
{
case LogMessageType.Exclamation:
iconName = "exclamation";
levelName = Resources.Messages.Exclamation;
break;
case LogMessageType.Warning:
iconName = "warning";
levelName = Resources.Messages.Warning;
break;
case LogMessageType.Success:
iconName = "success";
levelName = Resources.Messages.Success;
break;
case LogMessageType.Failure:
iconName = "failure";
levelName = Resources.Messages.Failure;
break;
default:
iconName = "information";
levelName = Resources.Messages.Information;
break;
}
logItem.Name = (_detailsList.Count - 1).ToString();
logItem.ImageKey = iconName;
logItem.Text = levelName;
logItem.SubItems.Add(Message);
logItem.SubItems.Add(MessageId != 0 ? MessageId.ToString() : "");
logItem.SubItems.Add(timeStamp);
LogList.BeginInvoke(new Action(() =>
{
try
{
LogList.Items.Add(logItem);
if (LogList.Items.Count > 1)
{
LogList.EnsureVisible(LogList.Items.Count - 1);
}
}
catch (Exception)
{
}
}));
}
if (Receiver.HasFlag(LogReceiver.StatusBar))
{
Color foreColor = Color.Black;
switch (MessageType)
{
case LogMessageType.Warning:
foreColor = Color.Orange;
break;
case LogMessageType.Failure:
case LogMessageType.Exclamation:
foreColor = Color.Red;
break;
default:
foreColor = Color.Black;
break;
}
LogList.BeginInvoke(new Action(() =>
{
StatusBarLabel.Text = Message;
StatusBarLabel.ForeColor = foreColor;
}));
if (MessageType == LogMessageType.Information || MessageType == LogMessageType.Success)
{
}
}
if (Receiver.HasFlag(LogReceiver.MessageBox))
{
MessageBoxIcon icon;
string title;
switch (MessageType)
{
case LogMessageType.Failure:
icon = MessageBoxIcon.Error;
title = Resources.Messages.Failure;
break;
case LogMessageType.Warning:
icon = MessageBoxIcon.Warning;
title = Resources.Messages.Warning;
break;
default:
icon = MessageBoxIcon.Information;
title = Resources.Messages.Information;
break;
}
AlertBox.Show(Message, title, icon, Details);
}
}
/// <summary>
/// Activates the log for loggers that match a regex pattern on the module name.
/// </summary>
/// <param name="regexPatternModule">The regex pattern to match a module name.</param>
/// <param name="minimumLevel">The minimum level.</param>
/// <param name="maximumLevel">The maximum level.</param>
/// <param name="enabledFlag">if set to <c>true</c> enaable the log, else disable.</param>
/// <exception cref="ArgumentNullException">If regexPatternModule is null</exception>
public static void ActivateLog(Regex regexPatternModule, LogMessageType minimumLevel, LogMessageType maximumLevel = LogMessageType.Fatal, bool enabledFlag = true)
{
if (regexPatternModule == null)
{
throw new ArgumentNullException("regexPatternModule");
}
ActivateLog(
logger =>
{
if (regexPatternModule.Match(logger.Module).Success)
{
logger.ActivateLog(minimumLevel, maximumLevel, enabledFlag);
}
});
}
// Help methods that use our FileSystem abstraction
public virtual void AppendLog(String message, LogMessageType messageType)
{
string textEntry = string.Format("{0:MM-dd-yyyy HH:mm:ss:ffff} :{1}: [{2}] {3}", DateTime.Now, System.Threading.Thread.CurrentThread.ManagedThreadId, messageType.ToString(), message);
AppendText(LogFileName, textEntry);
}
/// <summary>
/// Internal wrapper to log a message.
/// </summary>
/// <param name="msg"></param>
/// <param name="type"></param>
private void Log(string msg, LogMessageType type)
{
this.m_LoggingService.OnAddLogMessage(this, new LogMessageEventArgs(msg, type));
}
public virtual void AppendLog(Exception ex, LogMessageType messageType)
{
AppendLog(LogHelper.BuildExceptionMessage(ex, messageType), messageType);
}
public abstract void Log(LogMessageType type, bool logToConsole, string message);
/// <summary>
/// Writes a message to the console output if an output is available
/// </summary>
/// <param name="type">Error log type</param>
/// <param name="message">Formatted string, e.g. Starting proxy on port {0}</param>
/// <param name="args">List of arguments</param>
public void WriteLine(LogMessageType type, string message, params object[] args)
{
this.WriteLine(type, String.Format(message, args));
}
public static void Run(TestHelper helper)
{
Communicator?communicator = helper.Communicator();
TestHelper.Assert(communicator != null);
TextWriter output = helper.GetWriter();
bool ice1 = communicator.DefaultProtocol == Protocol.Ice1;
output.Write("testing communicator operations... ");
output.Flush();
{
// Test: Exercise AddAdminFacet, FindAdminFacet, RemoveAdminFacet with a typical configuration.
var properties = new Dictionary <string, string>
{
["Ice.Admin.Endpoints"] = ice1 ? "tcp -h 127.0.0.1" : "ice+tcp://127.0.0.1:0",
["Ice.Admin.InstanceName"] = "Test"
};
using var com = new Communicator(properties);
TestFacets(com, true, false);
}
{
// Test: Verify that the operations work correctly in the presence of facet filters.
var properties = new Dictionary <string, string>
{
["Ice.Admin.Endpoints"] = ice1 ? "tcp -h 127.0.0.1" : "ice+tcp://127.0.0.1:0",
["Ice.Admin.InstanceName"] = "Test",
["Ice.Admin.Facets"] = "Properties"
};
using var com = new Communicator(properties);
TestFacets(com, false, true);
}
{
// Test: Verify that the operations work correctly with the Admin object disabled.
using var com = new Communicator();
TestFacets(com, false, false);
}
{
// Test: Verify that the operations work correctly with Ice.Admin.Enabled=1
var properties = new Dictionary <string, string>()
{
{ "Ice.Admin.Enabled", "1" }
};
using var com = new Communicator(properties);
TestHelper.Assert(com.GetAdmin() == null);
var id = Identity.Parse("test-admin");
try
{
com.CreateAdmin(null, id);
TestHelper.Assert(false);
}
catch (InvalidConfigurationException)
{
}
ObjectAdapter adapter = com.CreateObjectAdapter();
TestHelper.Assert(com.CreateAdmin(adapter, id) != null);
TestHelper.Assert(com.GetAdmin() != null);
TestFacets(com, true, false);
}
{
// Test: Verify that the operations work correctly when creation of the Admin object is delayed.
var properties = new Dictionary <string, string>()
{
{ "Ice.Admin.Endpoints", ice1 ? "tcp -h 127.0.0.1" : "ice+tcp://127.0.0.1:0" },
{ "Ice.Admin.InstanceName", "Test" },
{ "Ice.Admin.DelayCreation", "1" }
};
using var com = new Communicator(properties);
TestFacets(com, true, false);
com.GetAdmin();
TestFacets(com, true, false);
}
output.WriteLine("ok");
var factory = IRemoteCommunicatorFactoryPrx.Parse(helper.GetTestProxy("factory", 0), communicator);
output.Write("testing process facet... ");
output.Flush();
{
// Test: Verify that Process.Shutdown() operation shuts down the communicator.
var props = new Dictionary <string, string>
{
{ "Ice.Admin.Endpoints", ice1 ? "tcp -h 127.0.0.1" : "ice+tcp://127.0.0.1:0" },
{ "Ice.Admin.InstanceName", "Test" }
};
IRemoteCommunicatorPrx?com = factory.CreateCommunicator(props);
TestHelper.Assert(com != null);
IObjectPrx?obj = com.GetAdmin();
TestHelper.Assert(obj != null);
IProcessPrx proc = obj.Clone("Process", IProcessPrx.Factory);
proc.Shutdown();
com.WaitForShutdown();
com.Destroy();
}
output.WriteLine("ok");
output.Write("testing properties facet... ");
output.Flush();
{
var props = new Dictionary <string, string>
{
{ "Ice.Admin.Endpoints", ice1 ? "tcp -h 127.0.0.1" : "ice+tcp://127.0.0.1:0" },
{ "Ice.Admin.InstanceName", "Test" },
{ "Prop1", "1" },
{ "Prop2", "2" },
{ "Prop3", "3" }
};
IRemoteCommunicatorPrx?com = factory.CreateCommunicator(props);
TestHelper.Assert(com != null);
IObjectPrx?obj = com.GetAdmin();
TestHelper.Assert(obj != null);
IPropertiesAdminPrx pa = obj.Clone("Properties", IPropertiesAdminPrx.Factory);
// Test: PropertiesAdmin.GetProperty()
TestHelper.Assert(pa.GetProperty("Prop2") == "2");
TestHelper.Assert(pa.GetProperty("Bogus").Length == 0);
// Test: PropertiesAdmin.GetProperties()
Dictionary <string, string> pd = pa.GetPropertiesForPrefix("");
TestHelper.Assert(pd.Count == 7);
TestHelper.Assert(pd["Ice.ProgramName"] == "server");
TestHelper.Assert(pd["Ice.Admin.Endpoints"] == (ice1 ? "tcp -h 127.0.0.1" : "ice+tcp://127.0.0.1:0"));
TestHelper.Assert(pd["Ice.Admin.InstanceName"] == "Test");
TestHelper.Assert(pd["Prop1"] == "1");
TestHelper.Assert(pd["Prop2"] == "2");
TestHelper.Assert(pd["Prop3"] == "3");
TestHelper.Assert(pd["Ice.Default.Protocol"] == communicator.DefaultProtocol.GetName());
Dictionary <string, string> changes;
// Test: PropertiesAdmin.SetProperties()
var setProps = new Dictionary <string, string>
{
{ "Prop1", "10" }, // Changed
{ "Prop2", "20" }, // Changed
{ "Prop3", "" }, // Removed
{ "Prop4", "4" }, // Added
{ "Prop5", "5" } // Added
};
pa.SetProperties(setProps);
TestHelper.Assert(pa.GetProperty("Prop1").Equals("10"));
TestHelper.Assert(pa.GetProperty("Prop2").Equals("20"));
TestHelper.Assert(pa.GetProperty("Prop3").Length == 0);
TestHelper.Assert(pa.GetProperty("Prop4").Equals("4"));
TestHelper.Assert(pa.GetProperty("Prop5").Equals("5"));
changes = com.GetChanges();
TestHelper.Assert(changes.Count == 5);
TestHelper.Assert(changes["Prop1"].Equals("10"));
TestHelper.Assert(changes["Prop2"].Equals("20"));
TestHelper.Assert(changes["Prop3"].Length == 0);
TestHelper.Assert(changes["Prop4"].Equals("4"));
TestHelper.Assert(changes["Prop5"].Equals("5"));
pa.SetProperties(setProps);
changes = com.GetChanges();
TestHelper.Assert(changes.Count == 0);
com.Destroy();
}
output.WriteLine("ok");
output.Write("testing logger facet... ");
output.Flush();
{
var props = new Dictionary <string, string>
{
{ "Ice.Admin.Endpoints", ice1 ? "tcp -h 127.0.0.1" : "ice+tcp://127.0.0.1:0" },
{ "Ice.Admin.InstanceName", "Test" },
{ "NullLogger", "1" }
};
IRemoteCommunicatorPrx?com = factory.CreateCommunicator(props);
TestHelper.Assert(com != null);
com.Trace("testCat", "trace");
com.Warning("warning");
com.Error("error");
com.Print("print");
IObjectPrx?obj = com.GetAdmin();
TestHelper.Assert(obj != null);
ILoggerAdminPrx logger = obj.Clone("Logger", ILoggerAdminPrx.Factory);
// Get all
(LogMessage[] logMessages, string prefix) =
logger.GetLog(Array.Empty <LogMessageType>(), Array.Empty <string>(), -1);
TestHelper.Assert(logMessages.Length == 4);
TestHelper.Assert(prefix.Equals("NullLogger"));
TestHelper.Assert(logMessages[0].TraceCategory.Equals("testCat") && logMessages[0].Message.Equals("trace"));
TestHelper.Assert(logMessages[1].Message.Equals("warning"));
TestHelper.Assert(logMessages[2].Message.Equals("error"));
TestHelper.Assert(logMessages[3].Message.Equals("print"));
// Get only errors and warnings
com.Error("error2");
com.Print("print2");
com.Trace("testCat", "trace2");
com.Warning("warning2");
LogMessageType[] messageTypes = { LogMessageType.ErrorMessage, LogMessageType.WarningMessage };
(logMessages, prefix) = logger.GetLog(messageTypes, Array.Empty <string>(), -1);
TestHelper.Assert(logMessages.Length == 4);
TestHelper.Assert(prefix.Equals("NullLogger"));
foreach (LogMessage msg in logMessages)
{
TestHelper.Assert(msg.Type == LogMessageType.ErrorMessage || msg.Type == LogMessageType.WarningMessage);
}
// Get only errors and traces with Cat = "testCat"
com.Trace("testCat2", "A");
com.Trace("testCat", "trace3");
com.Trace("testCat2", "B");
messageTypes = new LogMessageType[] { LogMessageType.ErrorMessage, LogMessageType.TraceMessage };
string[] categories = { "testCat" };
(logMessages, prefix) = logger.GetLog(messageTypes, categories, -1);
TestHelper.Assert(logMessages.Length == 5);
TestHelper.Assert(prefix.Equals("NullLogger"));
foreach (LogMessage msg in logMessages)
{
TestHelper.Assert(msg.Type == LogMessageType.ErrorMessage ||
(msg.Type == LogMessageType.TraceMessage && msg.TraceCategory.Equals("testCat")));
}
// Same, but limited to last 2 messages(trace3 + error3)
com.Error("error3");
(logMessages, prefix) = logger.GetLog(messageTypes, categories, 2);
TestHelper.Assert(logMessages.Length == 2);
TestHelper.Assert(prefix.Equals("NullLogger"));
TestHelper.Assert(logMessages[0].Message.Equals("trace3"));
TestHelper.Assert(logMessages[1].Message.Equals("error3"));
// Now, test RemoteLogger
ObjectAdapter adapter = communicator.CreateObjectAdapterWithEndpoints("RemoteLoggerAdapter",
ice1 ? "tcp -h localhost" : "ice+tcp://localhost:0", serializeDispatch: true);
var remoteLogger = new RemoteLogger();
IRemoteLoggerPrx myProxy = adapter.AddWithUUID(remoteLogger, IRemoteLoggerPrx.Factory);
adapter.Activate();
// No filtering
(logMessages, prefix) = logger.GetLog(Array.Empty <LogMessageType>(), Array.Empty <string>(), -1);
logger.AttachRemoteLogger(myProxy, Array.Empty <LogMessageType>(), Array.Empty <string>(), -1);
remoteLogger.Wait(1);
foreach (LogMessage m in logMessages)
{
remoteLogger.CheckNextInit(prefix, m.Type, m.Message, m.TraceCategory);
}
com.Trace("testCat", "rtrace");
com.Warning("rwarning");
com.Error("rerror");
com.Print("rprint");
remoteLogger.Wait(4);
remoteLogger.CheckNextLog(LogMessageType.TraceMessage, "rtrace", "testCat");
remoteLogger.CheckNextLog(LogMessageType.WarningMessage, "rwarning", "");
remoteLogger.CheckNextLog(LogMessageType.ErrorMessage, "rerror", "");
remoteLogger.CheckNextLog(LogMessageType.PrintMessage, "rprint", "");
TestHelper.Assert(logger.DetachRemoteLogger(myProxy));
TestHelper.Assert(!logger.DetachRemoteLogger(myProxy));
// Use Error + Trace with "traceCat" filter with 4 limit
(logMessages, prefix) = logger.GetLog(messageTypes, categories, 4);
TestHelper.Assert(logMessages.Length == 4);
logger.AttachRemoteLogger(myProxy, messageTypes, categories, 4);
remoteLogger.Wait(1);
foreach (LogMessage m in logMessages)
{
remoteLogger.CheckNextInit(prefix, m.Type, m.Message, m.TraceCategory);
}
com.Warning("rwarning2");
com.Trace("testCat", "rtrace2");
com.Warning("rwarning3");
com.Error("rerror2");
com.Print("rprint2");
remoteLogger.Wait(2);
remoteLogger.CheckNextLog(LogMessageType.TraceMessage, "rtrace2", "testCat");
remoteLogger.CheckNextLog(LogMessageType.ErrorMessage, "rerror2", "");
// Attempt reconnection with slightly different proxy
try
{
logger.AttachRemoteLogger(myProxy.Clone(oneway: true), messageTypes, categories, 4);
TestHelper.Assert(false);
}
catch (RemoteLoggerAlreadyAttachedException)
{
// expected
}
com.Destroy();
}
output.WriteLine("ok");
output.Write("testing custom facet... ");
output.Flush();
{
// Test: Verify that the custom facet is present.
var props = new Dictionary <string, string>
{
{ "Ice.Admin.Endpoints", ice1 ? "tcp -h 127.0.0.1" : "ice+tcp://127.0.0.1:0" },
{ "Ice.Admin.InstanceName", "Test" }
};
IRemoteCommunicatorPrx?com = factory.CreateCommunicator(props);
TestHelper.Assert(com != null);
IObjectPrx?obj = com.GetAdmin();
TestHelper.Assert(obj != null);
ITestFacetPrx tf = obj.Clone("TestFacet", ITestFacetPrx.Factory);
tf.Op();
com.Destroy();
}
output.WriteLine("ok");
output.Write("testing facet filtering... ");
output.Flush();
{
// Test: Set Ice.Admin.Facets to expose only the Properties facet, meaning no other facet is available.
var props = new Dictionary <string, string>
{
{ "Ice.Admin.Endpoints", ice1 ? "tcp -h 127.0.0.1" : "ice+tcp://127.0.0.1:0" },
{ "Ice.Admin.InstanceName", "Test" },
{ "Ice.Admin.Facets", "Properties" }
};
IRemoteCommunicatorPrx?com = factory.CreateCommunicator(props);
TestHelper.Assert(com != null);
IObjectPrx?obj = com.GetAdmin();
TestHelper.Assert(obj != null);
try
{
IProcessPrx.CheckedCast(obj.Clone(facet: "Process", IObjectPrx.Factory));
TestHelper.Assert(false);
}
catch (ObjectNotExistException)
{
}
try
{
ITestFacetPrx.CheckedCast(obj.Clone(facet: "TestFacet", IObjectPrx.Factory));
TestHelper.Assert(false);
}
catch (ObjectNotExistException)
{
}
com.Destroy();
}
{
// Test: Set Ice.Admin.Facets to expose only the Process facet, meaning no other facet is available.
var props = new Dictionary <string, string>
{
{ "Ice.Admin.Endpoints", ice1 ? "tcp -h 127.0.0.1" : "ice+tcp://127.0.0.1:0" },
{ "Ice.Admin.InstanceName", "Test" },
{ "Ice.Admin.Facets", "Process" }
};
IRemoteCommunicatorPrx?com = factory.CreateCommunicator(props);
TestHelper.Assert(com != null);
IObjectPrx?obj = com.GetAdmin();
TestHelper.Assert(obj != null);
try
{
IPropertiesAdminPrx.CheckedCast(obj.Clone(facet: "Properties", IObjectPrx.Factory));
TestHelper.Assert(false);
}
catch (ObjectNotExistException)
{
}
try
{
ITestFacetPrx.CheckedCast(obj.Clone(facet: "TestFacet", IObjectPrx.Factory));
TestHelper.Assert(false);
}
catch (ObjectNotExistException)
{
}
com.Destroy();
}
{
// Test: Set Ice.Admin.Facets to expose only the TestFacet facet, meaning no other facet is available.
var props = new Dictionary <string, string>
{
{ "Ice.Admin.Endpoints", ice1 ? "tcp -h 127.0.0.1" : "ice+tcp://127.0.0.1:0" },
{ "Ice.Admin.InstanceName", "Test" },
{ "Ice.Admin.Facets", "TestFacet" }
};
IRemoteCommunicatorPrx?com = factory.CreateCommunicator(props);
TestHelper.Assert(com != null);
IObjectPrx?obj = com.GetAdmin();
TestHelper.Assert(obj != null);
try
{
IPropertiesAdminPrx.CheckedCast(obj.Clone(facet: "Properties", IObjectPrx.Factory));
TestHelper.Assert(false);
}
catch (ObjectNotExistException)
{
}
try
{
IProcessPrx.CheckedCast(obj.Clone(facet: "Process", IObjectPrx.Factory));
TestHelper.Assert(false);
}
catch (ObjectNotExistException)
{
}
com.Destroy();
}
{
// Test: Set Ice.Admin.Facets to expose two facets. Use whitespace to separate the facet names.
var props = new Dictionary <string, string>
{
{ "Ice.Admin.Endpoints", ice1 ? "tcp -h 127.0.0.1" : "ice+tcp://127.0.0.1:0" },
{ "Ice.Admin.InstanceName", "Test" },
{ "Ice.Admin.Facets", "Properties TestFacet" }
};
IRemoteCommunicatorPrx?com = factory.CreateCommunicator(props);
TestHelper.Assert(com != null);
IObjectPrx?obj = com.GetAdmin();
TestHelper.Assert(obj != null);
IPropertiesAdminPrx pa = obj.Clone("Properties", IPropertiesAdminPrx.Factory);
TestHelper.Assert(pa.GetProperty("Ice.Admin.InstanceName").Equals("Test"));
var tf = ITestFacetPrx.CheckedCast(obj.Clone(facet: "TestFacet", IObjectPrx.Factory));
tf !.Op();
try
{
IProcessPrx.CheckedCast(obj.Clone(facet: "Process", IObjectPrx.Factory));
TestHelper.Assert(false);
}
catch (ObjectNotExistException)
{
}
com.Destroy();
}
{
// Test: Set Ice.Admin.Facets to expose two facets. Use a comma to separate the facet names.
var props = new Dictionary <string, string>
{
{ "Ice.Admin.Endpoints", ice1 ? "tcp -h 127.0.0.1" : "ice+tcp://127.0.0.1:0" },
{ "Ice.Admin.InstanceName", "Test" },
{ "Ice.Admin.Facets", "TestFacet, Process" }
};
IRemoteCommunicatorPrx?com = factory.CreateCommunicator(props);
TestHelper.Assert(com != null);
IObjectPrx?obj = com.GetAdmin();
TestHelper.Assert(obj != null);
try
{
IPropertiesAdminPrx.CheckedCast(obj.Clone(facet: "Properties", IObjectPrx.Factory));
TestHelper.Assert(false);
}
catch (ObjectNotExistException)
{
}
var tf = ITestFacetPrx.CheckedCast(obj.Clone(facet: "TestFacet", IObjectPrx.Factory));
TestHelper.Assert(tf != null);
tf.Op();
var proc = IProcessPrx.CheckedCast(obj.Clone(facet: "Process", IObjectPrx.Factory));
TestHelper.Assert(proc != null);
proc.Shutdown();
com.WaitForShutdown();
com.Destroy();
}
output.WriteLine("ok");
factory.Shutdown();
}
private void AppLog_OnTraceMessage(LogMessageType type, string traceMessage)
{
Console.WriteLine($"{traceMessage}");
}
