public async static Task <IImmutableList <SyntaxNode> > GenerateMocksAsync( ILogSink logSink, Language language, string solutionPath, string xmlPath) { if (!File.Exists(xmlPath)) { var message = $"XML input file '{xmlPath}' no found."; logSink.Error(logSource, message); throw new IOException(message); } logSink.Info(logSource, "Loading XML input file '{0}'.", xmlPath); var document = XDocument.Load(xmlPath); var configuration = Configuration.FromXDocument(logSink, document); return(await Generator.GenerateMocksAsync( logSink, language, solutionPath, configuration.GetInterfacePredicate(), configuration.GetNamespaceSelector(), configuration.GetNameSelector(), configuration.GetPlugins())); }
private static void LogMessage(MessageLevel level, string text, ILogSink logger) { if (!string.IsNullOrWhiteSpace(text)) { logger.Log(level, text); } }
public async Task WriteAsync(ILog log, byte[] logData) { List <Exception> exceptions = new List <Exception>(); ILogSink activeLogSink = null; foreach (var logSink in _logSinks) { try { activeLogSink = logSink; await activeLogSink.WriteAsync(log, logData); break; } catch (Exception ex) { exceptions.Add(ex); } } if (exceptions.Count > 0 && activeLogSink != null) { await WriteExceptionsAsync(activeLogSink, log, exceptions); } }
private static void ValidateLogger(ILogSink logger) { if (logger == null) { throw new ArgumentNullException("logger"); } }
public EpoxyTransport( ILayerStackProvider layerStackProvider, Func <string, Task <IPAddress> > resolver, EpoxyServerTlsConfig serverTlsConfig, EpoxyClientTlsConfig clientTlsConfig, TimeoutConfig timeoutConfig, ILogSink logSink, bool enableDebugLogs, IMetricsSink metricsSink) { // Layer stack provider may be null this.layerStackProvider = layerStackProvider; // Always need a resolver, so substitute in default if given null this.resolver = resolver ?? ResolveViaDnsAsync; // may be null - indicates no TLS for listeners this.serverTlsConfig = serverTlsConfig; // Client-side TLS is determined by how the connection is // established, so we substitute in the Default TLS config if we // happened to get null this.clientTlsConfig = clientTlsConfig ?? EpoxyClientTlsConfig.Default; this.timeoutConfig = timeoutConfig; // Log sink may be null logger = new Logger(logSink, enableDebugLogs); // Metrics sink may be null metrics = new Metrics(metricsSink); connections = new CleanupCollection <EpoxyConnection>(); listeners = new CleanupCollection <EpoxyListener>(); }
private void SinkFromFactory(SinkData sink) { LogSinkFactory factory = new LogSinkFactory(Context); ILogSink output = factory.CreateSink(sink.Name); Assert.IsNotNull(output); }
private static IEnumerable <SyntaxNode> GetMemberDeclarations( ILogSink logSink, SyntaxGenerator syntaxGenerator, SemanticModel semanticModel, string name, INamedTypeSymbol interfaceSymbol, Language language, IImmutableList <IPlugin> plugins) { return (new SyntaxNode[] { GetConstructorDeclarationSyntax(syntaxGenerator, semanticModel, name), GetConfigureBehaviorGeneratedSyntax(logSink, syntaxGenerator, semanticModel, interfaceSymbol, plugins), GetConfigureLooseBehaviorGeneratedSyntax(logSink, syntaxGenerator, semanticModel, interfaceSymbol, plugins), GetConfigureBehaviorMethodSyntax(language, syntaxGenerator, semanticModel), GetConfigureLooseBehaviorMethodSyntax(language, syntaxGenerator, semanticModel) } .Concat( GetMembersRecursive(interfaceSymbol) .Select(x => GetMemberDeclarationSyntax(syntaxGenerator, semanticModel, x)) .Where(x => x != null) .GroupBy(x => x, SyntaxNodeEqualityComparer.Instance) .Where(group => group.Count() == 1) .SelectMany(group => group) .Select(x => syntaxGenerator.AsPublicInterfaceImplementation(x, syntaxGenerator.TypeExpression(interfaceSymbol))))); }
public static void LogException <TIn1>(this ILogSink logger, string areaMethodName, TIn1 source, Type errorType, params object[] areaMethodParams) { string messageTemplate = GetMessageTemplate(areaMethodParams); logger.Log(LogEventLevel.Error, areaMethodName, source, messageTemplate, errorType.Name, string.Join(Environment.NewLine, areaMethodParams.ToJsonStrings())); }
public static void RedirectLogs(ILogSink logSink, out IReadOnlyDictionary <Type, LogSourceNameCompositionLogSink> redirectionLogSinks) { var redirectionSinks = new Dictionary <Type, LogSourceNameCompositionLogSink>(capacity: 2); { Type loggerType = typeof(global::Samples.WindowsService01.Log); const string logComponentGroupMoniker = "Samples.WindowsService01"; if (logSink == null) { redirectionSinks[loggerType] = null; global::Samples.WindowsService01.Log.Configure.EventHandlers.Error(null); global::Samples.WindowsService01.Log.Configure.EventHandlers.Info(null); global::Samples.WindowsService01.Log.Configure.EventHandlers.Debug(null); } else { var redirectionLogSink = new LogSourceNameCompositionLogSink(logComponentGroupMoniker, logSink); var logToSinkAdapter = new LogEventHandlersToLogSinkAdapter(redirectionLogSink); redirectionSinks[loggerType] = redirectionLogSink; global::Samples.WindowsService01.Log.Configure.EventHandlers.Error(logToSinkAdapter.Error); global::Samples.WindowsService01.Log.Configure.EventHandlers.Info(logToSinkAdapter.Info); global::Samples.WindowsService01.Log.Configure.EventHandlers.Debug(logToSinkAdapter.Debug); } Samples.WindowsService01.Log.Configure.DebugLoggingEnabled(IsDebugLoggingEnabled); } redirectionLogSinks = redirectionSinks; }
private static bool TryGetReturnValueSyntaxForImmutableStackReturnType( ILogSink logSink, SyntaxGenerator syntaxGenerator, SemanticModel semanticModel, INamedTypeSymbol returnType, out SyntaxNode returnValueSyntax) { var immutableStackInterfaceType = semanticModel .Compilation .GetTypeByMetadataName("System.Collections.Immutable.IImmutableStack`1"); if (returnType.ConstructedFrom != immutableStackInterfaceType) { returnValueSyntax = null; return(false); } var immutableStackType = semanticModel .Compilation .GetTypeByMetadataName("System.Collections.Immutable.ImmutableStack"); if (immutableStackType == null) { logSink.Warn(logSource, "Failed to resolve ImmutableStack class."); returnValueSyntax = null; return(false); } returnValueSyntax = syntaxGenerator.MemberAccessExpression( syntaxGenerator.WithTypeArguments( syntaxGenerator.TypeExpression(immutableStackType), syntaxGenerator.TypeExpression(returnType.TypeArguments[0])), "Empty"); return(true); }
public TfsSourceControlClient(string projectCollectionUrl, string userName, string password, string domain, ILogSink log) { var uri = new Uri(projectCollectionUrl, UriKind.Absolute); if (string.IsNullOrEmpty(userName)) { this.collection = TfsTeamProjectCollectionFactory.GetTeamProjectCollection(uri); } else { TfsClientCredentials credentials; if (string.IsNullOrEmpty(domain)) { credentials = new TfsClientCredentials(new BasicAuthCredential(new NetworkCredential(userName, password))); } else { credentials = new TfsClientCredentials(new WindowsCredential(new NetworkCredential(userName, password, domain))); } this.collection = new TfsTeamProjectCollection(uri, credentials); } this.log = log; }
private static bool TryGetReturnValueSyntaxForSetReturnType( ILogSink logSink, SyntaxGenerator syntaxGenerator, SemanticModel semanticModel, INamedTypeSymbol returnType, out SyntaxNode returnValueSyntax) { var setInterfaceType = semanticModel .Compilation .GetTypeByMetadataName("System.Collections.Generic.ISet`1"); if (returnType.ConstructedFrom != setInterfaceType) { returnValueSyntax = null; return(false); } var dictionaryType = semanticModel .Compilation .GetTypeByMetadataName("System.Collections.Generic.HashSet`1"); if (dictionaryType == null) { logSink.Warn(logSource, "Failed to resolve HashSet<T> class."); returnValueSyntax = null; return(false); } returnValueSyntax = syntaxGenerator.ObjectCreationExpression( dictionaryType.Construct(returnType.TypeArguments[0])).NormalizeWhitespace(); return(true); }
internal static async Task WrapInVirtualEnv(ILogSink logger, IOperationExecutionContext context, RemoteProcessStartInfo startInfo, string pythonExePath, string virtualEnv) { if (string.IsNullOrEmpty(virtualEnv)) { return; } var fileOps = await context.Agent.GetServiceAsync <IFileOperationsExecuter>(); if (!await fileOps.DirectoryExistsAsync(virtualEnv)) { var procExec = await context.Agent.GetServiceAsync <IRemoteProcessExecuter>(); logger.LogDebug($"Virtual environment in {virtualEnv} is not present. Attempting venv (Python 3.3+)..."); var success = false; using (var process = procExec.CreateProcess(new RemoteProcessStartInfo { FileName = pythonExePath, WorkingDirectory = context.WorkingDirectory, Arguments = "-m venv -- " + virtualEnv, })) { process.OutputDataReceived += (s, e) => logger.LogDebug("(venv) " + e.Data); process.ErrorDataReceived += (s, e) => logger.LogDebug("(venv) " + e.Data); await process.WaitAsync(context.CancellationToken); success = process.ExitCode == 0; } if (!success) { logger.LogDebug("Attempting virtualenv (any Python version, but requires separate installation)..."); using var process = procExec.CreateProcess( new RemoteProcessStartInfo { FileName = "virtualenv", WorkingDirectory = context.WorkingDirectory, Arguments = "-- " + virtualEnv, EnvironmentVariables = { ["VIRTUALENV_PYTHON"] = pythonExePath } } ); process.OutputDataReceived += (s, e) => logger.LogDebug("(virtualenv) " + e.Data); process.ErrorDataReceived += (s, e) => logger.LogDebug("(virtualenv) " + e.Data); await process.WaitAsync(context.CancellationToken); success = process.ExitCode == 0; } if (!success) { throw new ExecutionFailureException("Could not create a virtual environment. See debug logs from this operation for more information."); } } startInfo.FileName = (await fileOps.GetFileInfoAsync(fileOps.CombinePath(virtualEnv, "bin", "python"))).FullName; }
/// <summary> /// Replaces this context's log sink with <paramref name="logSink"/>. /// </summary> /// <param name="logSink"> /// The new log sink. /// </param> /// <returns> /// The new context. /// </returns> public Context WithLogSink(ILogSink logSink) => new Context( logSink, this.language, this.plugins, this.syntaxGenerator, this.semanticModel);
/// <summary> /// Registers the provided log sink. /// </summary> /// <param name="sink">The log sink.</param> public void RegisterLogSink(ILogSink sink) { if (null != sink) { this.AttachedLoggers.Add(sink); } }
public static void RemoveLogSink(ILogSink logSink) { lock (m_lock) { m_logSinks.Remove(logSink); } }
public static IImmutableList <SyntaxNode> GenerateMocks( ILogSink logSink, Language language, IImmutableList <Compilation> compilations, string xmlPath) { logSink = logSink .WithSource(typeof(XmlBasedGenerator)); if (!File.Exists(xmlPath)) { logSink.Error("XML input file '{0}' not found.", xmlPath); return(ImmutableList <SyntaxNode> .Empty); } logSink.Info("Loading XML input file '{0}'.", xmlPath); var document = XDocument.Load(xmlPath); var configuration = Configuration.FromXDocument(logSink, document); return(Generator.GenerateMocks( logSink, language, compilations, configuration.GetPlugins(), configuration.GetInterfacePredicate(), configuration.GetNamespaceSelector(), configuration.GetNameSelector())); }
private MappedWorkspace(Workspace workspace, string diskPath, bool deleteOnDispose, ILogSink log) { this.Workspace = workspace; this.DiskPath = diskPath; this.DeleteOnDispose = deleteOnDispose; this.log = log; }
/// <inheritdoc /> public SyntaxNode GenerateConfigureLooseBehavior( ILogSink logSink, SyntaxGenerator syntaxGenerator, SemanticModel semanticModel, ISymbol symbol) { return(null); }
public LogEvent(string ipAddress, string user, string topic, LogEventType type, ILogSink sink) { IP = ipAddress; User = user; Topic = topic; Type = type; Sink = sink; }
public LogEventHandlersToLogSinkAdapter(ILogSink targetLogSink) { if (targetLogSink == null) { throw new ArgumentNullException(nameof(targetLogSink)); } _targetLogSink = targetLogSink; }
public SvnClient(UsernamePasswordCredentials credentials, Agent agent, string svnExePath, ILogSink log, CancellationToken?cancellationToken = null) { this.execOps = new Lazy <IRemoteProcessExecuter>(() => agent.GetService <IRemoteProcessExecuter>()); this.userName = credentials?.UserName; this.password = credentials?.Password; this.svnExePath = AH.CoalesceString(svnExePath, RemoteMethods.GetEmbeddedSvnExePath(agent)); this.log = log ?? (ILogSink)Logger.Null; this.cancellationToken = cancellationToken ?? CancellationToken.None; }
internal SvnClient(UsernamePasswordCredentials credentials, IRemoteProcessExecuter execOps, string svnExePath, ILogSink log, CancellationToken?cancellationToken = null) { this.execOps = new Lazy <IRemoteProcessExecuter>(() => execOps); this.userName = credentials?.UserName; this.password = credentials?.Password; this.svnExePath = svnExePath; this.log = log ?? (ILogSink)Logger.Null; this.cancellationToken = cancellationToken ?? CancellationToken.None; }
private static bool TryDisposeLogSink(ILogSink logSink) { if (logSink is IDisposable disposableLogSink) { disposableLogSink.Dispose(); } return(true); }
public JenkinsClient(string username, SecureString password, string serverUrl, bool csrfProtectionEnabled, ILogSink logger = null, CancellationToken cancellationToken = default) { this.username = username; this.password = password; this.serverUrl = serverUrl; this.csrfProtectionEnabled = csrfProtectionEnabled; this.logger = logger; this.cancellationToken = cancellationToken; }
public SimplerAsyncLog(ILogSink sink) { this._sink = sink; this._tokenSource = new CancellationTokenSource(); this._mainLoop = new Task(() => this.MainLoop(this._tokenSource.Token), this._tokenSource.Token); this._mainLoop.Start(); }
public static IisVirtualDirectoryConfiguration FromMwaVirtualDirectory(ILogSink logger, string siteName, VirtualDirectory vdir, IisVirtualDirectoryConfiguration template = null) { var config = new IisVirtualDirectoryConfiguration(); config.SiteName = siteName; config.ApplicationPath = template?.ApplicationPath; config.SetPropertiesFromMwa(logger, vdir, template); return(config); }
public ImportFilesService( IHostApplicationLifetime hostApplicationLifetime, IImportFilesWorker importFilesWorker, ILogSink logger) { _hostApplicationLifetime = hostApplicationLifetime; _importFilesWorker = importFilesWorker; _logger = logger; }
public static void AddLogSink(ILogSink logSink) { lock (m_lock) { if (!m_logSinks.Contains(logSink)) { m_logSinks.Add(logSink); } } }
public static IisApplicationConfiguration FromMwaApplication(ILogSink logger, string siteName, Application app, IisApplicationConfiguration template = null) { var config = new IisApplicationConfiguration(); config.SiteName = siteName; config.ApplicationPath = app.Path; config.ApplicationPoolName = app.ApplicationPoolName; config.SetPropertiesFromMwa(logger, app.VirtualDirectories["/"], template); return(config); }
public RemoteTemporaryFile(IFileOperationsExecuter fileOps, ILogSink log) { this.fileOps = fileOps; this.log = log; string workingDirectory = fileOps.GetBaseWorkingDirectory(); string fileName = Guid.NewGuid().ToString("n"); this.Path = fileOps.CombinePath(workingDirectory, fileName); }
private async Task<EpoxyTransport> Server( ILogSink logSink, IMetricsSink metricsSink, IPEndPoint endPoint) { var transport = new EpoxyTransportBuilder() .SetLogSink(logSink) .SetMetricsSink(metricsSink) .Construct(); var service = new DummyTestService(); var listener = transport.MakeListener(endPoint); listeners.Add(listener); listener.AddService(service); await listener.StartAsync(); return transport; }
public Logger(ILogSink logSink) { _sinks.Add(logSink); }
public LoggerFactory (ILogSink logSink) { _logSink = logSink; }
public void Add(ILogSink logSink) { _sinks.Add(logSink); }
public LoggerMiddleware(AppFunc next, ILogSink logger, IEnvironmentFormatter formatter) { _next = next; _logger = logger; _formatter = formatter ?? new EnvironmentFormatter(); }
public static void RemoveSink(ILogSink sink) { lock (Sinks) Sinks.Remove(sink); }
public Log (string name, ILogSink logSink) { _name = name; _logSink = logSink; }
public LoggerOwinMiddleware(OwinMiddleware next, ILogSink logger) : this(next, logger, null) { }
public ExceptionHandler(ILogSink log) { this.log = log; }
public LoggerOwinMiddleware(OwinMiddleware next, ILogSink logger, IOwinContextFormatter formatter) : base(next) { _logger = logger; _formatter = formatter ?? new OwinContextFormatter(); }
public Logger(ILogSink sink, bool includeDebug) { Sink = sink; IncludeDebug = includeDebug; }
public static void AddSink(ILogSink sink) { lock (Sinks) Sinks.Add(sink); }
public LoggerMiddleware(AppFunc next, ILogSink logger) : this(next, logger, null) { }
public void AddLogSink(ILogSink logSink) { }