private static void LogProgressMessage(Logger logger, LogLevel level, string message) { var logEvent = new LogEventInfo(level, logger.Name, message); logEvent.Properties.Add("Status", ""); logger.Log(logEvent); }
public MainForm(string[] args) { InitializeComponent(); logger = LogManager.GetLogger(""); logger.Log(LogLevel.Info, "Starting up..."); btnExit.Click += delegate { Exit(); }; btnMinimize.Click += delegate { ShowHide(); }; showHideToolStripMenuItem.Click += delegate { ShowHide(); }; exitToolStripMenuItem.Click += delegate { Exit(); }; notifyIcon.Text = Program.FullName; this.Text = Program.FullName; model = new Model(this.components, logger); HookModel(); if (!model.Initialize()) { this.Close(); //Application.Exit(); } PopulateFolderList(); if (args.Length > 0) { if (!model.LoadTorrent(args[0])) errorOnLoad = true; } }
/// <summary> /// </summary> /// <param name="logger"></param> /// <param name="logItem"></param> public static void Log(Logger logger, LogItem logItem) { if (!Constants.EnableNLog) { return; } switch (String.IsNullOrWhiteSpace(logItem.Message)) { case true: if (logItem.Exception == null) { return; } logger.LogException(logItem.LogLevel, logItem.Exception.Message, logItem.Exception); break; case false: if (logItem.Exception == null) { logger.Log(logItem.LogLevel, logItem.Message); } else { logger.LogException(logItem.LogLevel, logItem.Message, logItem.Exception); } break; } }
private static void LogCleansedMessage(Logger logger, LogLevel level, string message) { message = Cleanse(message); var logEvent = new LogEventInfo(level, logger.Name, message); logger.Log(logEvent); }
public override void OnActionExecuting(ActionExecutingContext filterContext) { _logger = LogManager.GetLogger(filterContext.Controller.GetType().FullName); var eventInfo = new LogEventInfo( LogLevel.Info, _logger.Name, filterContext.Controller.GetType().Name + "." + filterContext.ActionDescriptor.ActionName); _logger.Log(eventInfo); }
private static void Log(Logger logger, LogLevel level, Exception exception, string extendedInfo, string format, params object[] args) { var eventInfo = exception == null ? new LogEventInfo(level, logger.Name, CultureInfo.InvariantCulture, format, args) : new LogEventInfo(level, logger.Name, CultureInfo.InvariantCulture, format, args, exception); if (extendedInfo != null) eventInfo.Properties["extendedInfo"] = extendedInfo; logger.Log(eventInfo); }
public void LogData <T>(T model) { var propValues = DictionaryObjectConvert.DictionarySimpleContractConvert(model); var logEventInfo = LogEventInfo.Create(LogLevel.Info, _nlog.Name, $"{typeof(T)}_数据库日志"); foreach (var prop in propValues) { logEventInfo.Properties[prop.Key] = prop.Value; } _nlog.Log(logEventInfo); }
private static void SendMessage(LogLevel level, object sender, string message, Exception exception = null) { NLogLogger logger = GetLoggerBySender(sender); LogEventInfo evt = new LogEventInfo(level, logger.Name, message); if (exception != null) { evt.Exception = exception; } logger.Log(evt); }
/// <summary> /// Log to the wrapped NLog logger /// </summary> public void LogInternal(LogLevel level, string message, Exception ex = null) { var nlogEntry = new LogEventInfo { Level = level, TimeStamp = DateTime.UtcNow, Message = message, Exception = ex }; logger.Log(DeclaringType, nlogEntry); }
public ABank(int processCount) { _logger = NLog.LogManager.GetLogger("test"); // Trace - Warn levelları arasında FileManager2'yi kullanacak. _logger.Log(LogLevel.Info, "Create"); this._processCount = processCount; for (int i = 0; i < _processCount; i++) { keyValuePairs.TryAdd(i, i * i); } }
static void LogEvent(NLogger logger, NLogLevel level, string logSource, Exception exception, string message, params object[] parameters) { var logEvent = new LogEventInfo(level, logger.Name, null, message, parameters, exception); logEvent.Properties["logSource"] = logSource; logger.Log(logEvent); }
public string Log(Zenchi.Domain.LogLevel level, string message) { string id = Guid.NewGuid().ToString(); logger.Log(GetLevel(level), string.Format("{0} - {1}", id, message)); return(id); }
public bool CheckIfDatabaseConnectable() { var provider = "System.Data.SqlClient"; // for example var factory = DbProviderFactories.GetFactory(provider); using (var connection = factory.CreateConnection()) { connection.ConnectionString = _connectionString; try { connection.Open(); _logger.Log(LogLevel.Info, "SQL Connection is OPEN!"); return(true); } catch { _logger.Log(LogLevel.Error, "SQL Connection is CLOSED!"); return(false); } } }
/// <summary> /// Logs the specified format. /// </summary> /// <param name="level">The logging level.</param> /// <param name="format">The format.</param> /// <param name="args">The arguments. If an object instance is part of the list, it will be JSON-serialized</param> public virtual void Log(LoggingLevel level, string format, params object[] args) { var loglevel = GetLogLevel(level); if (!_logger.IsEnabled(loglevel)) { return; } if (!string.IsNullOrWhiteSpace(format)) { if (args != null && args.Length > 0) { for (int i = args.Length - 1; i >= 0; i--) { if (args[i] != null) { if (args[i].GetType().IsPrimitiveType()) { continue; } try { args[i] = JsonConvert.SerializeObject(args[i]); } catch { } } } } _logger.Log(loglevel, format, args); if (_logToDb) { new LogLogic().InsertLog(_logger.Name, HttpContext.Current, level, string.Format(format, args)); } } }
public static void Log(Logger logger, string message, Exception exception, LogLevel level = null) { if (logger == null) { return; } if (level == null) { level = LogLevel.Error; } logger.Log(level, message, exception); }
public static void Log(Logger logger, string message, LogLevel level = null) { if (logger == null) { return; } if (level == null) { level = LogLevel.Trace; } logger.Log(level, message); }
public static void Log(string message, params object[] args) { if (Logger != null) { var msg = string.Format(message, args); Logger.Log(LogLevel.Trace, msg); Report(msg); } else { Console.WriteLine(message, args); } }
public void Log(LoggerEntryLevel level, string message, Exception exception = null) { var logEvent = new LogEventInfo(LogLevel.FromOrdinal((int)level), Name, message) { Exception = exception }; foreach (string key in _staticProperties.Keys) { logEvent.Properties[key] = _staticProperties[key]; } _log.Log(logEvent); }
public void Write(LogType type, string msg) { var level = typeErrorMap[type]; var eventInfo = new LogEventInfo(level, logger.Name, msg); eventInfo.Properties["msg_type"] = type; eventInfo.Properties["sender"] = owner; logger.Log(eventInfo); if (level >= LogLevel.Error) { LastError = $"{DateTime.Now} {msg}"; } }
private static void log(LogLevel logLevel, string msg, params object[] format) { LogEventInfo logEvent = new LogEventInfo(level: logLevel, loggerName: NLogger.Name, formatProvider: CultureInfo.InvariantCulture, message: msg, parameters: format); NLogger.Log(typeof(Logger), logEvent); if (format.Length > 0) { Console.WriteLine(msg, format); } else { Console.WriteLine(msg); } }
private void RaiseLogEvent(LogEventInfo logEventInfo) { if (logEventInfo != null) { if (_logger == null) { _logger = LogManager.GetLogger(LoggerName); } if (_logger != null) { _logger.Log(logEventInfo); } } }
/// <summary> /// 写入日志 /// </summary> /// <param name="level">日志级别</param> /// <param name="message">日志消息</param> /// <param name="exception">异常信息</param> public void Log(LogLevel level, string message, Exception exception) { if (!IsEnabled(level)) { return; } if (string.IsNullOrWhiteSpace(message) && exception == null) { return; } var eventInfo = NLogs.LogEventInfo.Create(GetLevel(level), _logger.Name, exception, CultureInfo.CurrentCulture, message); _logger.Log(eventInfo); }
/// <summary> /// log to file direct /// </summary> /// <param name="level"></param> /// <param name="message"></param> /// <param name="exception"></param> public void LogToFile(LogType level, string message, Exception exception = null) { string clientAddress = ""; try { clientAddress = System.Web.HttpContext.Current.Request.UserHostAddress; } catch { } var enableLog = ConfigurationManager.AppSettings["enableLog"].ToString(); if (enableLog == "true") { switch (level) { case LogType.Info: logman.Log(LogLevel.Info, message, exception); return; case LogType.Warning: logman.Log(LogLevel.Warn, message, exception); return; case LogType.Trace: logman.Log(LogLevel.Trace, message, exception); return; } if (exception?.InnerException != null) { string m = Environment.NewLine + " ----- Exception start " + DateTime.Now.ToString("dd-MM-yyyy HH:mm:ss.FFF") + " ," + clientAddress + " -----" + Environment.NewLine; m = m + Environment.NewLine + " Message:" + message + Environment.NewLine; try { m = m + Environment.NewLine + " Exception Type:" + exception.InnerException.GetType().Name + Environment.NewLine; } catch { } m = m + Environment.NewLine + " Exception Source:" + exception.Source + Environment.NewLine; m = m + Environment.NewLine + " Exception Message: " + exception.Message + Environment.NewLine; m = m + Environment.NewLine + " ----- Exception End " + DateTime.Now.ToString("dd-MM-yyyy HH:mm:ss.FFF") + " ----- " + Environment.NewLine; logman.Log(LogLevel.Error, m, exception); } } }
/// <summary> /// Write to the log /// </summary> /// <param name="level">Log level</param> /// <param name="text">Text with format</param> /// <param name="args">Format args</param> public static void Write(LogLevel level, string text, params object[] args) { try { if (args != null && args.Length != 0) { text = string.Format(text, args); } logger?.Log(GetNLogLevel(level), text); } catch { // oh well... } }
public static void Log(Exception ex, string type) { try { if (Globals.EnableElasticSearchLogging) { //ElasticSearch.Log(ex, type); } var logLevel = LogLevel.FromString(type); _log_.Log(logLevel, ex, ex.Message); } catch (Exception) { } }
public static void EnsureExists() { logger.Log(LogLevel.Info, "Making sure DB exists"); var assembly = Assembly.GetExecutingAssembly(); using Stream stream = assembly.GetManifestResourceStream("NoisEvader.CreateDb.sql"); using StreamReader reader = new StreamReader(stream); string sql = reader.ReadToEnd(); DoQuery(command => { command.CommandText = sql; command.ExecuteNonQuery(); }); }
public static void WriteLog(LogLevel logType, Exception exception, string message, params string[] args) { var loggerEventEmitter = new LogEventInfo(logType, logger.Name, null, message, args); if (exception != null) { loggerEventEmitter.Exception = exception; if (exception.InnerException != null) { loggerEventEmitter.Exception = exception.InnerException; } } // check with wrapper type typeof(Logger); logger.Log(typeof(CustomLogger), loggerEventEmitter); }
public void MyMethod1() { logger.Trace("Sampel Trace message"); logger.Trace("Sampel Debug message"); logger.Info("Sample Info message"); logger.Warn("Sample Warning message"); logger.Error("Sample Error message"); logger.Fatal("Sampel fatal error message"); logger.Log(LogLevel.Info, "Sample informational message"); try { } catch (Exception ex) { logger.Error(ex, "异常"); } }
private void HandleAggregateException(NLog.Logger logger, Exception exception) { var aggregateException = exception as AggregateException; if (aggregateException == null) { return; } aggregateException.Handle( e => { logger.Log(NLog.LogLevel.Error, e, $"CorrelationId:{this.GetCorrelationId()}, {e.Message}"); this.HandleReflectionTypeLoadException(logger, e); return(false); }); }
private void CommonLogic(ExceptionContext context) { // https://github.com/nlog/nlog/wiki/Tutorial NLog.Logger logger = NLog.LogManager.GetLogger("Logger"); logger.Error(context); if (!string.IsNullOrEmpty(context.Exception.StackTrace)) { logger.Log(LogLevel.Error, context.Exception.StackTrace); } HttpStatusCode status = HttpStatusCode.InternalServerError; String message = String.Empty; var exceptionType = context.Exception.GetType(); if (exceptionType == typeof(UnauthorizedAccessException)) { message = "Unauthorized Access"; status = HttpStatusCode.Unauthorized; } else if (exceptionType == typeof(NotImplementedException)) { message = "A server error occurred."; status = HttpStatusCode.NotImplemented; } else if (exceptionType == typeof(CustomExceptionExample)) { message = context.Exception.ToString(); status = HttpStatusCode.InternalServerError; } else { message = context.Exception.Message; status = HttpStatusCode.NotFound; } context.ExceptionHandled = true; // <--- *** EXTREMELY IMPORTANT *** HttpResponse response = context.HttpContext.Response; response.StatusCode = (int)status; response.ContentType = "application/json"; var err = $"{message} context.Exception.StackTrace"; response.WriteAsync(err); }
/// <summary> /// Write to the log /// </summary> /// <param name="level">Log level</param> /// <param name="ts">Timestamp</param> /// <param name="text">Text with format</param> /// <param name="args">Format args</param> private static void Write(IPBanCore.LogLevel level, DateTime ts, string text, params object[] args) { try { #if DEBUG if (level == LogLevel.Error || level == LogLevel.Critical || level == LogLevel.Fatal) { // System.Diagnostics.Debugger.Break(); } #endif //timeSource.CurrentTime = ts; nlogInstance?.Log(GetNLogLevel(level), text, args); } catch { } }
public void Log(LogLevel logLevel, EventId eventId, Exception exception, string message) { var nLogLogLevel = ConvertLogLevel(logLevel); if (IsEnabled(nLogLogLevel)) { if (!string.IsNullOrEmpty(message)) { //message arguments are not needed as it is already checked that the loglevel is enabled. var eventInfo = _NLog.LogEventInfo.Create(nLogLogLevel, _logger.Name, message); eventInfo.Exception = exception; eventInfo.Properties["EventId.Id"] = eventId.Id; eventInfo.Properties["EventId.Name"] = eventId.Name; eventInfo.Properties["EventId"] = eventId; _logger.Log(eventInfo); } } }
private static void Log(LogLevel logLevel, string message, string loggerName, Exception ex) { if (!Logger.IsEnabled(logLevel)) { return; } var eventInfo = new LogEventInfo { Message = message, Level = logLevel, LoggerName = loggerName, Exception = ex, }; eventInfo.Properties.Add("FullStackTrace", ex.ToString()); Logger.Log(eventInfo); }
private static void WriteLog(LogLevel level, string message, Exception ex, params NlogVariable[] customvariables) { var dblog = LogEventInfo.Create(level, dbLogger.Name, message, ex); var filelog = LogEventInfo.Create(level, fileLogger.Name, message, ex); if (customvariables != null) { foreach (var item in customvariables) { dblog.Properties[item.VariableName] = item.Value; } foreach (var item in customvariables) { filelog.Properties[item.VariableName] = item.Value; } } dbLogger.Log(dblog); fileLogger.Log(filelog); }
/// <summary> /// Write to the log /// </summary> /// <param name="level">Log level</param> /// <param name="text">Text with format</param> /// <param name="args">Format args</param> public static void Write(LogLevel level, string text, params object[] args) { try { if (args != null && args.Length != 0) { text = string.Format(text, args); } logger?.Log(GetNLogLevel(level), text); LogWrite?.Invoke(new LoggerEvent() { level = level, text = text, args = args }); } catch { // oh well... } }
public static void Initialize(Action<NLogConfigurationApi> configure = null) { if (_logger != null) return; var config = new NLogConfigurationApi(); if (configure != null) { configure(config); } _logger = SetupNLog(config); LoggingFacade.Initialize((level, message) => { var nLogLevel = LevelToNLogLevel(level); _logger.Log(nLogLevel, message); }); }
private void HandleReflectionTypeLoadException(NLog.Logger logger, Exception exception) { var reflectionTypeLoadException = exception as ReflectionTypeLoadException; if (reflectionTypeLoadException == null) { return; } var loadExceptions = reflectionTypeLoadException.LoaderExceptions; if (loadExceptions != null) { foreach (var loadException in loadExceptions) { logger.Log(NLog.LogLevel.Error, loadException, $"CorrelationId:{this.GetCorrelationId()}, {loadException.Message}"); } } }
private static void GenerateLog <T>(string message, LogLevel logLevel, Exception ex, T data) { if (ex == null) { ex = new Exception(message); } if (data != null) { ex.Data.Add("Input", data); } var logEvent = new LogEventInfo(logLevel, _logger.Name, message) { Exception = new System.Exception(message), }; //var l = new LogEventInfo(logLevel, message, null, message); _logger.Log(typeof(CustomLogger), logEvent); }
private static void InnerEventLog(LogLevel logLevel, string message, int eventCode, SystemEventLevel eventLevel, bool logMessageToConsole) { try { var logEvent = new LogEventInfo(logLevel, _systemEventLogger.Name, message); logEvent.Properties["eventCode"] = eventCode; logEvent.Properties["eventLevel"] = (int)eventLevel; _systemEventLogger.Log(logEvent); if (logMessageToConsole) { Info(string.Format("For EventLog: ({0}) {1}", logLevel, message)); } } catch { //логгер ни когда не должен падать } }
static void GenerateData(Logger logger, DateTime init, DateTime @from) { var rand = new Random(); var levels = new[] { LogLevel.Trace, LogLevel.Debug, LogLevel.Info, LogLevel.Warn }; var messages = File.ReadAllLines(GetPath("messages.txt")); var tags = File.ReadAllText(GetPath("tags.txt")).Split(' ').Select(t => t.Trim(new[] { '.' })).ToArray(); Console.WriteLine("Starting live data generation."); while (true) { logger.Log(levels[rand.Next(levels.Length)], messages[rand.Next(messages.Length)], tags: new[] { tags[rand.Next(tags.Length)] }, fields: new Dictionary<string, object> { { "curr-position", DateTime.UtcNow - init } }); Thread.Sleep(20); } }
private static void ProcessPackagesConfig( CurrentOperation operation, string[] conflictPaths, DirectoryInfo folder, Logger logger, string rootFolder ) { var packagesConfigMerger = new PackagesConfigMerger( operation, new UserConflictResolver<ConfigitPackageReference>( operation, repositoryRootDirectory: rootFolder ) ); foreach ( var conflict in conflictPaths.Where( p => Path.GetFileName( p ) == "packages.config" ) ) { var fullConflictPath = Path.Combine( folder.FullName, conflict ); logger.Info( $"{LogHelper.Header}{Environment.NewLine}Examining concurrent modification for {fullConflictPath}" ); var baseContent = GitHelper.GetConflictContent( rootFolder, StageLevel.Ancestor, conflict ); var localContent = GitHelper.GetConflictContent( rootFolder, StageLevel.Ours, conflict ); var incomingContent = GitHelper.GetConflictContent( rootFolder, StageLevel.Theirs, conflict ); // TODO: Is this correct? if base is not null then we have a deletion of the packages config file if ( string.IsNullOrEmpty( localContent ) || string.IsNullOrEmpty( incomingContent ) ) { logger.Log( LogLevel.Info, $"Skipping '{conflict}' - no content on one side" ); continue; } bool resolved = false; try { var result = packagesConfigMerger.Merge( conflict, baseContent == null ? new ConfigitPackageReference[0]: NuGetExtensions.ReadPackageReferences( baseContent ), NuGetExtensions.ReadPackageReferences( localContent ), NuGetExtensions.ReadPackageReferences( incomingContent ) ).ToArray(); result.Write( fullConflictPath ); using ( var repository = new Repository( rootFolder ) ) { repository.Stage( conflict ); resolved = true; } } catch ( MergeAbortException ) { logger.Log( LogLevel.Info, $"Package merge aborted for {conflict}" ); continue; } catch ( UserQuitException ) { throw; } catch ( Exception exception ) { logger.Log( LogLevel.Error, exception, $"Package merge failed for {conflict}{Environment.NewLine}{exception}" ); } if ( resolved ) { continue; } string userQuestionText = $"Could not resolve conflict: {conflict}{Environment.NewLine}Would you like to resolve the conflict with the mergetool?"; var userQuestion = new UserQuestion<bool>( userQuestionText, UserQuestion<bool>.YesNoOptions() ); if ( !userQuestion.Resolve() ) { continue; } XDocument localDocument = XDocument.Parse( localContent ); XDocument theirDocument = XDocument.Parse( incomingContent ); XDocument baseDocument = baseContent == null ? new XDocument() : XDocument.Parse( baseContent ); using ( var repository = new Repository( rootFolder ) ) { GitHelper.ResolveWithStandardMergetool( repository, fullConflictPath, baseDocument, localDocument, theirDocument, logger, conflict ); } } }
public static void ErrorMessageWithLog(Window parent, string userMessage, Logger logger, Exception ex, LogLevel level = null) { if (level == null) level = LogLevel.Error; logger.Log (level, ex, userMessage); ErrorMessage (parent, ex, userMessage); }
private static void ProcessProjectFiles( CurrentOperation operation, string[] conflictPaths, DirectoryInfo folder, Logger logger, string rootFolder ) { var merger = new ProjectMerger( operation, new UserConflictResolver<ProjectReference>( operation, repositoryRootDirectory: rootFolder ), new ReferenceConflictResolver( new UserConflictResolver<Reference>( operation, notResolveOptionText: PackageNotInstalledText, repositoryRootDirectory: rootFolder ) ), new UserConflictResolver<RawItem>( operation, repositoryRootDirectory: rootFolder ), new UserDuplicateResolver<Reference>( operation, notResolveOptionText: PackageNotInstalledText, repositoryRootDirectory: rootFolder ) ); foreach ( var conflict in conflictPaths.Where( p => p.EndsWith( ".csproj" ) || p.EndsWith( ".fsproj" ) || p.EndsWith( ".xproj" )) ) { var fullConflictPath = Path.Combine( folder.FullName, conflict ); logger.Info( $"{LogHelper.Header}{Environment.NewLine}Examining concurrent modification for {fullConflictPath}" ); var baseContent = GitHelper.GetConflictContent( rootFolder, StageLevel.Ancestor, conflict ); var localContent = GitHelper.GetConflictContent( rootFolder, StageLevel.Ours, conflict ); var incomingContent = GitHelper.GetConflictContent( rootFolder, StageLevel.Theirs, conflict ); var conflictFolder = Path.GetDirectoryName( Path.Combine( rootFolder, conflict ) ); if ( conflictFolder == null ) { throw new Exception( "No conflict folder" ); } if ( string.IsNullOrEmpty( localContent ) || string.IsNullOrEmpty( incomingContent ) ) { logger.Log( LogLevel.Info, $"Skipping '{conflict}' - no content on one side" ); continue; } var localDocument = XDocument.Parse( localContent ); var incomingDocument = XDocument.Parse( incomingContent ); var baseDocument = XDocument.Parse( baseContent ?? "<?xml version=\"1.0\" encoding=\"utf - 8\"?><Project/>" ); var resolved = false; try { var projectFolder = Path.Combine( folder.FullName, conflictFolder ); var packagesConfigFilePath = ProjectPackages.GetPackagesConfigFilePath( projectFolder ); var packagesConfig = ProjectPackages.TryLoadPackagesConfig( packagesConfigFilePath ); if ( packagesConfig == null ) { continue; } var packageIndex = new ProjectPackages( projectFolder, NuGetExtensions.FindRelativePathOfPackagesFolder( projectFolder ), packagesConfig ); Item[] items = merger.Merge( conflict, packageIndex, baseDocument, localDocument, incomingDocument ).ToArray(); // Now remove everything we have handled, to check if we are done. ProjectFile.DeleteItems( localDocument ); ProjectFile.DeleteItems( incomingDocument ); ProjectFile.DeleteItems( baseDocument ); ProjectFile.AddItems( baseDocument, items ); ProjectFile.AddItems( localDocument, items ); ProjectFile.AddItems( incomingDocument, items ); XDocument resolvedDocument = null; var localXml = localDocument.ToString(); var incomingXml = incomingDocument.ToString(); var baseXml = baseDocument.ToString(); // Check for any project file changes outside of the references and items. if ( localXml == incomingXml ) { resolvedDocument = localDocument; } else if ( baseXml == localXml ) { resolvedDocument = incomingDocument; } else if ( baseXml == incomingXml ) { resolvedDocument = localDocument; } if ( resolvedDocument != null ) { // We handled all the differences using ( var textWriter = new StreamWriter( fullConflictPath ) ) { SerialisationHelper.WriteXml( resolvedDocument, textWriter ); } using ( var repository = new Repository( rootFolder ) ) { repository.Stage( conflict ); } resolved = true; } } catch ( MergeAbortException ) { logger.Log( LogLevel.Info, $"Project merge aborted for {conflict}" ); continue; } catch ( UserQuitException ) { throw; } catch ( Exception exception ) { logger.Log( LogLevel.Error, exception, $"Project merge failed for {conflict}{Environment.NewLine}{exception}" ); } if ( resolved ) { continue; } string userQuestionText = $"Could not resolve conflict: {conflict}{Environment.NewLine}Would you like to resolve the conflict with the mergetool?"; var userQuestion = new UserQuestion<bool>( userQuestionText, UserQuestion<bool>.YesNoOptions() ); if ( userQuestion.Resolve() ) { using ( var repository = new Repository( rootFolder ) ) { GitHelper.ResolveWithStandardMergetool( repository, fullConflictPath, baseDocument, localDocument, incomingDocument, logger, conflict ); } } } }
private static void WriteEntry(Logger logger, JobLogEntry entry) { LogEventInfo evt = new LogEventInfo( entry.FullEvent.Level, entry.FullEvent.LoggerName, CultureInfo.CurrentCulture, entry.FullEvent.FormattedMessage, new object[0]) { TimeStamp = entry.Timestamp.LocalDateTime }; logger.Log(evt); }
private static void ProcessSolutionFiles( CurrentOperation operation, string[] conflictPaths, DirectoryInfo folder, Logger logger, string rootFolder) { foreach (var conflictPath in conflictPaths.Where(cp => cp.ToLowerInvariant().EndsWith(".sln"))) { try { ProcessSolutionFile(operation, folder, logger, rootFolder, conflictPath); } catch (Exception e) { logger.Log(LogLevel.Error, e, "Failed to process solution file " + conflictPath); } } }
static void Main(string[] args) { ConfigureLogging(_verboseLogging); _logger = LogManager.GetCurrentClassLogger(); var filePath = ""; var connectionString = ""; var showHelp = false; var p = new OptionSet { { "f|file=", "The assembly which should be uploaded", v => { if (v != null) filePath = v; } }, { "c|connection=", "The target for the upload", v => { if (v != null) connectionString = v; } }, { "v|verbose", "Verbose log output", v => { if (v != null) _verboseLogging = true; } }, { "h|help", "show this message and exit", v => showHelp = v != null }, }; try { p.Parse(args); } catch (OptionException e) { var name = Path.GetFileNameWithoutExtension(Assembly.GetExecutingAssembly().Location); Console.Write("{0}: ", name); Console.WriteLine(e.Message); Console.WriteLine("Try `{0} --help' for more information.", name); return; } if (_verboseLogging) { ConfigureLogging(_verboseLogging); } if (showHelp) { ShowHelp(p); return; } if (string.IsNullOrWhiteSpace(filePath)) { _logger.Log(LogLevel.Error, () => "Missing filePath."); ShowHelp(p); Environment.Exit(1); } else { if (!File.Exists(filePath)) { _logger.Log(LogLevel.Error, () => string.Format("Could not find the specified file at {0}", filePath)); Environment.Exit(100); } } if (string.IsNullOrWhiteSpace(connectionString)) { _logger.Log(LogLevel.Error, () => "Missing connectionstring."); ShowHelp(p); Environment.Exit(2); } var assembly = Assembly.ReflectionOnlyLoadFrom(filePath); // TODO catch NotFound _logger.Log(LogLevel.Info, () => "Loaded assembly."); var con = CrmConnection.Parse(connectionString); var service = new OrganizationService(con); var pluginAssemblyId = FindPluginAssembly(service, assembly.GetName().Name); if (pluginAssemblyId != Guid.Empty) { UpdatePluginAssembly(service, pluginAssemblyId, filePath); } else { _logger.Log(LogLevel.Error, () => "Sorry, I am unable to find the appropriate assembly in the specified CRM organization. Is it already registered?"); Environment.Exit(3); } }