/// <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); }