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