/// <summary>
/// Creates an environment
/// </summary>
public static DelegateEnvironment Create(int?seed = null, int verbose = 0,
MessageSensitivity sensitivity = (MessageSensitivity)(-1),
ILogWriter outWriter = null, ILogWriter errWriter = null)
{
return(new DelegateEnvironment(seed: seed, verbose: verbose, sensitivity: sensitivity,
outWriter: outWriter, errWriter: errWriter));
}
private void Helper(IExceptionContext ectx, MessageSensitivity expected)
{
Contracts.AssertValueOrNull(ectx);
bool caught = false;
try
{
ectx.CheckParam(false, nameof(ectx), "Whoops");
}
catch (Exception e)
{
Assert.Equal(expected, e.Sensitivity());
caught = true;
}
Assert.True(caught, "Exception was not caught at all");
caught = false;
try
{
throw ectx.ExceptNotSupp("Oops!");
}
catch (Exception e)
{
Assert.Equal(expected, e.Sensitivity());
caught = true;
}
Assert.True(caught, "Exception was not caught at all");
}
public DelegateEnvironment(int?seed = null, int verbose = 0,
MessageSensitivity sensitivity = MessageSensitivity.All, int conc = 0,
ILogWriter outWriter = null, ILogWriter errWriter = null)
: this(RandomUtils.Create(seed), verbose, sensitivity, conc, outWriter, errWriter)
{
_elapsed = true;
}
private string LinePrefix(MessageSensitivity sensitivity)
{
if (_parent._sensitivityFlags == MessageSensitivity.All || ((_parent._sensitivityFlags & sensitivity) != MessageSensitivity.None))
{
return(null);
}
return("SystemLog:");
}
public ChannelMessage(ChannelMessageKind kind, MessageSensitivity sensitivity, string message)
{
Contracts.CheckNonEmpty(message, nameof(message));
Kind = kind;
Sensitivity = sensitivity;
_message = message;
_args = null;
}
public DelegateEnvironment(HostEnvironmentBase <DelegateEnvironment> source,
int?seed = null, int verbose = 0,
MessageSensitivity sensitivity = MessageSensitivity.All,
ILogWriter outWriter = null, ILogWriter errWriter = null)
: this(source, RandomUtils.Create(seed), verbose, sensitivity, outWriter, errWriter)
{
_elapsed = true;
}
public ChannelMessage(ChannelMessageKind kind, MessageSensitivity sensitivity, string fmt, params object[] args)
{
Contracts.CheckNonEmpty(fmt, nameof(fmt));
Contracts.CheckNonEmpty(args, nameof(args));
Kind = kind;
Sensitivity = sensitivity;
_message = fmt;
_args = args;
}
private string WriteAndReturnLinePrefix(MessageSensitivity sensitivity, TextWriter writer)
{
string prefix = LinePrefix(sensitivity);
if (prefix != null)
{
writer.Write(prefix);
}
return(prefix);
}
// REVIEW: do we really care about custom random? If we do, let's make this ctor public.
/// <summary>
/// Create an ML.NET environment for local execution, with console feedback.
/// </summary>
/// <param name="rand">An custom source of randomness to use in the environment.</param>
/// <param name="verbose">Set to <c>true</c> for fully verbose logging.</param>
/// <param name="sensitivity">Allowed message sensitivity.</param>
/// <param name="outWriter">Text writer to print normal messages to.</param>
/// <param name="errWriter">Text writer to print error messages to.</param>
private ConsoleEnvironment(Random rand, bool verbose = false,
MessageSensitivity sensitivity = MessageSensitivity.All,
TextWriter outWriter = null, TextWriter errWriter = null)
: base(rand, verbose, nameof(ConsoleEnvironment))
{
Contracts.CheckValueOrNull(outWriter);
Contracts.CheckValueOrNull(errWriter);
_consoleWriter = new ConsoleWriter(this, outWriter ?? Console.Out, errWriter ?? Console.Error);
_sensitivityFlags = sensitivity;
AddListener <ChannelMessage>(PrintMessage);
}
/// <summary>
/// This takes ownership of the random number generator.
/// </summary>
public DelegateEnvironment(int?seed, int verbose = 0,
MessageSensitivity sensitivity = MessageSensitivity.All,
ILogWriter outWriter = null, ILogWriter errWriter = null)
: base(seed, verbose > 0, nameof(DelegateEnvironment))
{
Contracts.CheckValue(outWriter, nameof(outWriter));
Contracts.CheckValue(errWriter, nameof(errWriter));
Contracts.CheckParam(verbose >= 0 && verbose <= 4, nameof(verbose), "verbose must be in [[0, 4]]");
_outErrWriter = new OutErrLogWriter(this, outWriter, errWriter, verbose);
_sensitivityFlags = sensitivity;
_verbose = verbose;
AddListener <ChannelMessage>(PrintMessage);
}
/// <summary>
/// This takes ownership of the random number generator.
/// </summary>
public DelegateEnvironment(Random rand, int verbose = 0,
MessageSensitivity sensitivity = MessageSensitivity.All, int conc = 0,
WriteType outWriter = null, WriteType errWriter = null)
: base(rand, verbose > 0, conc, nameof(DelegateEnvironment))
{
Contracts.CheckValueOrNull(outWriter);
Contracts.CheckValueOrNull(errWriter);
Contracts.CheckParam(verbose >= 0 && verbose <= 4, nameof(verbose), "verbose must be in [[0, 4]]");
_outErrWriter = new OutErrLogWriter(this, new LogWriter(outWriter), new LogWriter(errWriter), verbose);
_sensitivityFlags = sensitivity;
_verbose = verbose;
AddListener <ChannelMessage>(PrintMessage);
}
public static ConsoleEnvironment NewTestEnvironment(out StringWriter sout, out StringWriter serr,
int?seed = null, bool verbose = false,
MessageSensitivity sensitivity = (MessageSensitivity)(-1),
int conc = 0)
{
var sb = new StringBuilder();
sout = new StringWriter(sb);
sb = new StringBuilder();
serr = new StringWriter(sb);
return(NewTestEnvironment(seed: seed, verbose: verbose, sensitivity: sensitivity,
conc: conc, outWriter: sout, errWriter: serr));
}
private static TlcEnvironment CreateEnvironment()
{
string sensitivityString = null;
MessageSensitivity sensitivity = MessageSensitivity.All;
if (!string.IsNullOrWhiteSpace(sensitivityString))
{
// Cannot use host or channels since the environment isn't even
// created yet.
if (!Enum.TryParse(sensitivityString, out sensitivity))
{
Console.Error.WriteLine("Cannot parse '{0}' as {1}", sensitivityString, nameof(MessageSensitivity));
sensitivity = MessageSensitivity.All;
}
}
return(new TlcEnvironment(sensitivity: sensitivity));
}
/// <summary>
/// Exceptions whose message communicates potentially sensitive information should be
/// marked using this method, before they are thrown. Note that if the exception already
/// had this flag set, the message will be flagged with the bitwise or of the existing
/// flag, alongside the passed in sensivity.
/// </summary>
public static TException MarkSensitive <TException>(this TException ex, MessageSensitivity sensitivity)
where TException : Exception
{
AssertValue(ex);
MessageSensitivity innerSensitivity;
if (!ex.Data.Contains(SensitivityKey))
{
innerSensitivity = MessageSensitivity.None;
}
else
{
innerSensitivity = (ex.Data[SensitivityKey] as MessageSensitivity?) ?? MessageSensitivity.None;
}
ex.Data[SensitivityKey] = innerSensitivity | sensitivity;
return(ex);
}
public static TlcEnvironment NewTestEnvironment(int?seed = null, bool verbose = false,
MessageSensitivity sensitivity = (MessageSensitivity)(-1),
int conc = 0, TextWriter outWriter = null, TextWriter errWriter = null)
{
if (!seed.HasValue)
{
seed = 42;
}
if (outWriter == null)
{
outWriter = new StreamWriter(new MemoryStream());
}
if (errWriter == null)
{
errWriter = new StreamWriter(new MemoryStream());
}
return(new TlcEnvironment(seed, verbose, sensitivity, conc, outWriter, errWriter));
}
/// <summary>
/// Creates a new environment. It should be done
/// with <tt>using</tt>.
/// </summary>
public static ConsoleEnvironment NewTestEnvironment(int?seed = null, bool verbose = false,
MessageSensitivity sensitivity = (MessageSensitivity)(-1),
int conc = 0, TextWriter outWriter = null, TextWriter errWriter = null)
{
if (!seed.HasValue)
{
seed = 42;
}
if (outWriter == null)
{
outWriter = new StreamWriter(new MemoryStream());
}
if (errWriter == null)
{
errWriter = new StreamWriter(new MemoryStream());
}
var env = new ConsoleEnvironment(seed, verbose, sensitivity, conc, outWriter, errWriter);
ComponentHelper.AddStandardComponents(env);
return(env);
}
public SensitiveExceptionContext(IExceptionContext inner, MessageSensitivity toMark)
{
AssertValueOrNull(inner);
Inner = inner;
ToMark = toMark;
}
public void Trace(MessageSensitivity sensitivity, string fmt, params object[] args)
{
this.Channel?.Trace(sensitivity, fmt, args);
}
public void Warning(MessageSensitivity sensitivity, string fmt)
{
this.Channel?.Warning(sensitivity, fmt);
}
public void Info(MessageSensitivity sensitivity, string fmt, params object[] args)
{
Dispatch(this, new ChannelMessage(ChannelMessageKind.Info, sensitivity, fmt, args));
}
public void Info(MessageSensitivity sensitivity, string fmt)
{
this.Channel?.Info(sensitivity, fmt);
}
public void Warning(MessageSensitivity sensitivity, string msg)
{
Dispatch(this, new ChannelMessage(ChannelMessageKind.Warning, sensitivity, msg));
}
public void Info(MessageSensitivity sensitivity, string msg)
{
Dispatch(this, new ChannelMessage(ChannelMessageKind.Info, sensitivity, msg));
}
public void Error(MessageSensitivity sensitivity, string msg)
{
Dispatch(this, new ChannelMessage(ChannelMessageKind.Error, sensitivity, msg));
}
public void Trace(MessageSensitivity sensitivity, string msg)
{
Dispatch(this, new ChannelMessage(ChannelMessageKind.Trace, sensitivity, msg));
}
private static ConsoleEnvironment CreateEnvironment()
{
MessageSensitivity sensitivity = MessageSensitivity.All;
return(new ConsoleEnvironment(sensitivity: sensitivity));
}
public void Error(MessageSensitivity sensitivity, string fmt)
{
this.Channel?.Error(sensitivity, fmt);
}
public void Trace(MessageSensitivity sensitivity, string fmt)
{
this.Channel?.Trace(sensitivity, fmt);
}
/// <summary>
/// Create an ML.NET <see cref="IHostEnvironment"/> for local execution, with console feedback.
/// </summary>
/// <param name="seed">Random seed. Set to <c>null</c> for a non-deterministic environment.</param>
/// <param name="verbose">Set to <c>true</c> for fully verbose logging.</param>
/// <param name="sensitivity">Allowed message sensitivity.</param>
/// <param name="outWriter">Text writer to print normal messages to.</param>
/// <param name="errWriter">Text writer to print error messages to.</param>
public ConsoleEnvironment(int?seed = null, bool verbose = false,
MessageSensitivity sensitivity = MessageSensitivity.All,
TextWriter outWriter = null, TextWriter errWriter = null)
: this(RandomUtils.Create(seed), verbose, sensitivity, outWriter, errWriter)
{
}
public void Warning(MessageSensitivity sensitivity, string fmt, params object[] args)
{
this.Channel?.Warning(sensitivity, fmt, args);
}
