public IHttpActionResult GetCommits()
{
CommitsModel vm;
UnitOfWork unitOfWork = null;
System.Diagnostics.Trace.TraceInformation("Get Commits");
try
{
unitOfWork = new UnitOfWork();
var parameters = this.Request.GetQueryNameValuePairs();
CommitQuery query = new CommitQuery(unitOfWork.Context.Commits);
var keyword = parameters.FirstOrDefault(p => p.Key == "keyword").Value;
if (string.IsNullOrEmpty(keyword) == false)
{
query.Keyword = parameters.FirstOrDefault(p => p.Key == "keyword").Value;
}
query.ExcludeApproved = String.Equals("true", parameters.FirstOrDefault(p => p.Key == "excludeApproved").Value, StringComparison.InvariantCulture);
query.Max = Parser.ParseNullable <int>(parameters.FirstOrDefault(p => p.Key == "max").Value);
query.IncludeAuthor = parameters.FirstOrDefault(p => p.Key == "include").Value;
query.ExcludeAuthor = parameters.FirstOrDefault(p => p.Key == "exclude").Value;
query.Project = Parser.ParseNullable <int>(parameters.FirstOrDefault(p => p.Key == "project").Value);
var list = new List <Tuple <Commit, CommitStats> >();
foreach (var commit in query.Execute())
{
var comments = unitOfWork.Context.Comments.Where(c => c.Revision == commit.Revision).ToList();
var replies = comments.Where(c => c.User == commit.Author && c.IsLike == false);
var reviews = comments.Where(c => c.User != commit.Author && c.IsLike == false);
var likes = comments.Where(c => c.IsLike == true);
var stats = new CommitStats(
reviews.Select(c => c.User).Distinct().Count(),
reviews.Count(),
replies.Count(),
likes.Count());
list.Add(new Tuple <Commit, CommitStats>(commit, stats));
}
vm = new CommitsModel(list);
return(Ok(vm));
}
catch (Exception ex)
{
System.Diagnostics.Trace.TraceError("GetRevision: " + ex);
return(InternalServerError(ex));
}
finally
{
if (unitOfWork != null)
{
unitOfWork.Dispose();
}
}
}
private BuildStatistics CreateCommitsStats(BuildCommits buildCommits, BuildInfo buildInfo)
{
var result = new BuildStatistics(buildInfo);
var buildCommit = buildCommits.BuildCommit;
var compareList = new List <Commit>();
compareList.Add(buildCommit);
compareList.AddRange(buildCommits.PreviousCommits);
var tracker = new FilesStatisticsTracker();
for (int i = 0; i < compareList.Count; i++)
{
var commitA = compareList.ElementAtOrDefault(i);
var commitB = compareList.ElementAtOrDefault(i + 1);
if (commitA == null || commitB == null)
{
break;
}
var commitStats = new CommitStats();
commitStats.LocalDateTime = commitA.Author.When.LocalDateTime;
commitStats.Commit = commitA.Sha;
commitStats.Author = commitA.Author.Name;
var diff = this.repository.Diff.Compare <Patch>(commitB.Tree, commitA.Tree);
foreach (var file in diff)
{
tracker.AddAuthor(file.Path, file.OldPath, commitA.Author.Name);
tracker.IncreaseRevision(file.Path, file.OldPath);
var fileStats = new FileStats();
fileStats.Path = file.Path;
fileStats.OldPath = file.OldPath;
fileStats.NumberOfModifiedLines = file.LinesAdded + file.LinesDeleted;
fileStats.BuildResult = buildInfo.BuildResult;
fileStats.GitObjectId = file.Oid.Sha;
commitStats.AddFileStats(fileStats);
}
result.AddStats(commitStats);
}
foreach (var loopStat in result.CommitStats)
{
foreach (var loopFile in loopStat.FileStats)
{
loopFile.NumberOfDistinctCommitters = tracker.GetDisctinctAuthorsCount(loopFile.Path);
loopFile.NumberOfRevisions = tracker.GetRevisionsCount(loopFile.Path);
}
}
return(result);
}
} // TODO not used ????
public CommitDetailViewModel(Commit commit, CommitStats stats)
{
Revision = commit.Revision;
Author = commit.Author;
Message = commit.Message;
Timestamp = commit.Timestamp;
NumberReviewers = stats.NumberReviewers;
NumberComments = stats.NumberComments;
NumberReplies = stats.NumberReplies;
ApprovedBy = commit.ApprovedBy;
}
public static void Notify(CommitStats stats, DocumentDatabase database)
{
if (stats.NumberOf4KbsWrittenToDisk == 0 ||
// we don't want to raise the error too often
stats.WriteToJournalDuration.TotalMilliseconds < 500)
{
return;
}
var writtenDataInMb = stats.NumberOf4KbsWrittenToDisk / (double)256;
var seconds = stats.WriteToJournalDuration.TotalSeconds;
var rateOfWritesInMbPerSec = writtenDataInMb / seconds;
if (rateOfWritesInMbPerSec < 1)
{
database.NotificationCenter.SlowWrites.Add(stats.JournalFilePath, writtenDataInMb, seconds);
}
}
private void CompletePreviousTransaction(
DocumentsOperationContext context,
RavenTransaction previous,
CommitStats commitStats,
ref List <MergedTransactionCommand> previousPendingOps,
bool throwOnError)
{
try
{
_recording.State?.Record(context, TxInstruction.EndAsyncCommit);
previous.EndAsyncCommit();
//not sure about this 'if'
if (commitStats != null)
{
SlowWriteNotification.Notify(commitStats, _parent);
}
if (_log.IsInfoEnabled)
{
_log.Info($"EndAsyncCommit on {previous.InnerTransaction.LowLevelTransaction.Id}");
}
NotifyOnThreadPool(previousPendingOps);
}
catch (Exception e)
{
foreach (var op in previousPendingOps)
{
op.Exception = e;
}
NotifyOnThreadPool(previousPendingOps);
previousPendingOps = null; // RavenDB-7417
if (throwOnError)
{
throw;
}
}
}
private Metric CreateStat(BuildInfo current, CommitStats commitStats, FileStats fileStats)
{
var stat = new Metric();
stat.BuildCommit = current.CommitHash;
stat.BuildResult = (int)current.BuildResult;
stat.Commit = commitStats.Commit;
stat.ExportDateUtc = DateTime.UtcNow;
stat.NumberOfDistinctCommitters = fileStats.NumberOfDistinctCommitters;
stat.NumberOfModifiedLines = fileStats.NumberOfModifiedLines;
stat.NumberOfRevisions = fileStats.NumberOfRevisions;
stat.OldPath = fileStats.OldPath;
stat.Path = fileStats.Path;
stat.BuildCommitDateTimeLocal = commitStats.LocalDateTime;
stat.BuildDateTimeLocal = current.BuildDateTimeLocal;
stat.Author = commitStats.Author;
stat.BuildProjectName = current.BuildProjectName;
stat.ProjectName = this.appConfiguration.ImportProjectName;
stat.ObjectId = fileStats.GitObjectId;
return(stat);
}
public static void Notify(CommitStats stats, DocumentDatabase database)
{
if (stats.NumberOf4KbsWrittenToDisk == 0 ||
// we don't want to raise the error too often
stats.WriteToJournalDuration.TotalMilliseconds < 500)
{
return;
}
var writtenDataInMb = stats.NumberOf4KbsWrittenToDisk / (double)256;
var seconds = stats.WriteToJournalDuration.TotalSeconds;
var rateOfWritesInMbPerSec = writtenDataInMb / seconds;
if (rateOfWritesInMbPerSec < 1)
{
database.NotificationCenter.Add(PerformanceHint.Create(database.Name,
$"An extremely slow write to disk.",
$"We wrote {writtenDataInMb:N} MB in {seconds:N} seconds ({rateOfWritesInMbPerSec:N} MB/s) to: '{stats.JournalFilePath}'",
PerformanceHintType.SlowIO,
NotificationSeverity.Info,
$"TxMerger/{Path.GetDirectoryName(stats.JournalFilePath)}"
));
}
}
public void RetrieveCommitStats(out CommitStats stats)
{
_requestedCommitStats = stats = new CommitStats();
}
private void MergeTransactionsWithAsyncCommit(
ref DocumentsOperationContext previous,
ref IDisposable returnPreviousContext,
List <MergedTransactionCommand> previousPendingOps)
{
DocumentsOperationContext current = null;
IDisposable currentReturnContext = null;
try
{
while (true)
{
if (_log.IsInfoEnabled)
{
_log.Info($"BeginAsyncCommit on {previous.Transaction.InnerTransaction.LowLevelTransaction.Id} with {_operations.Count} additional operations pending");
}
currentReturnContext = _parent.DocumentsStorage.ContextPool.AllocateOperationContext(out current);
CommitStats commitStats = null;
try
{
previous.Transaction.InnerTransaction.LowLevelTransaction.RetrieveCommitStats(out commitStats);
_recording.State?.Record(current, TxInstruction.BeginAsyncCommitAndStartNewTransaction);
current.Transaction = previous.Transaction.BeginAsyncCommitAndStartNewTransaction(current);
}
catch (Exception e)
{
foreach (var op in previousPendingOps)
{
op.Exception = e;
}
NotifyOnThreadPool(previousPendingOps);
if (e is OutOfMemoryException)
{
try
{
//already throwing, attempt to complete previous tx
CompletePreviousTransaction(previous, previous.Transaction, commitStats, ref previousPendingOps, throwOnError: false);
}
finally
{
current.Transaction?.Dispose();
currentReturnContext.Dispose();
}
}
return;
}
var currentPendingOps = GetBufferForPendingOps();
PendingOperations result;
bool calledCompletePreviousTx = false;
try
{
var transactionMeter = TransactionPerformanceMetrics.MeterPerformanceRate();
try
{
result = ExecutePendingOperationsInTransaction(
currentPendingOps, current,
previous.Transaction.InnerTransaction.LowLevelTransaction.AsyncCommit, ref transactionMeter);
UpdateGlobalReplicationInfoBeforeCommit(current);
}
finally
{
transactionMeter.Dispose();
}
calledCompletePreviousTx = true;
CompletePreviousTransaction(previous, previous.Transaction, commitStats, ref previousPendingOps, throwOnError: true);
}
catch (Exception e)
{
using (current.Transaction)
using (currentReturnContext)
{
if (calledCompletePreviousTx == false)
{
CompletePreviousTransaction(
previous,
previous.Transaction,
commitStats,
ref previousPendingOps,
// if this previous threw, it won't throw again
throwOnError: false);
}
else
{
throw;
}
}
if (e is HighDirtyMemoryException highDirtyMemoryException)
{
if (_log.IsInfoEnabled)
{
var errorMessage = $"{currentPendingOps.Count:#,#0} operations were cancelled because of high dirty memory, details: {highDirtyMemoryException.Message}";
_log.Info(errorMessage, highDirtyMemoryException);
}
NotifyHighDirtyMemoryFailure(currentPendingOps, highDirtyMemoryException);
}
else
{
if (_log.IsInfoEnabled)
{
_log.Info($"Failed to run merged transaction with {currentPendingOps.Count:#,#0} operations in async manner, will retry independently", e);
}
NotifyTransactionFailureAndRerunIndependently(currentPendingOps, e);
}
return;
}
_recording.State?.Record(previous, TxInstruction.DisposePrevTx, previous.Transaction.Disposed == false);
previous.Transaction.Dispose();
returnPreviousContext.Dispose();
previous = current;
returnPreviousContext = currentReturnContext;
switch (result)
{
case PendingOperations.CompletedAll:
try
{
previous.Transaction.InnerTransaction.LowLevelTransaction.RetrieveCommitStats(out var stats);
_recording.State?.Record(current, TxInstruction.Commit);
previous.Transaction.Commit();
SlowWriteNotification.Notify(stats, _parent);
}
catch (Exception e)
{
foreach (var op in currentPendingOps)
{
op.Exception = e;
}
}
NotifyOnThreadPool(currentPendingOps);
return;
case PendingOperations.HasMore:
previousPendingOps = currentPendingOps;
break;
default:
Debug.Assert(false);
return;
}
}
}
catch
{
if (current.Transaction != null)
{
_recording.State?.Record(current, TxInstruction.DisposeTx, current.Transaction.Disposed == false);
current.Transaction.Dispose();
}
currentReturnContext?.Dispose();
throw;
}
}
private void MergeTransactionsWithAsyncCommit(
DocumentsOperationContext context,
List <MergedTransactionCommand> previousPendingOps)
{
var previous = context.Transaction;
try
{
while (true)
{
if (_log.IsInfoEnabled)
{
_log.Info($"BeginAsyncCommit on {previous.InnerTransaction.LowLevelTransaction.Id} with {_operations.Count} additional operations pending");
}
CommitStats commitStats = null;
try
{
previous.InnerTransaction.LowLevelTransaction.RetrieveCommitStats(out commitStats);
context.Transaction = previous.BeginAsyncCommitAndStartNewTransaction();
}
catch (Exception e)
{
foreach (var op in previousPendingOps)
{
op.Exception = e;
}
NotifyOnThreadPool(previousPendingOps);
if (e is OutOfMemoryException)
{
try
{
//already throwing, attempt to complete previous tx
CompletePreviousTransaction(previous, commitStats, ref previousPendingOps, throwOnError: false);
}
finally
{
context.Transaction?.Dispose();
}
}
return;
}
try
{
var currentPendingOps = GetBufferForPendingOps();
PendingOperations result;
bool calledCompletePreviousTx = false;
try
{
var transactionMeter = TransactionPerformanceMetrics.MeterPerformanceRate();
try
{
result = ExecutePendingOperationsInTransaction(
currentPendingOps, context,
previous.InnerTransaction.LowLevelTransaction.AsyncCommit, ref transactionMeter);
UpdateGlobalReplicationInfoBeforeCommit(context);
}
finally
{
transactionMeter.Dispose();
}
calledCompletePreviousTx = true;
CompletePreviousTransaction(previous, commitStats, ref previousPendingOps, throwOnError: true);
}
catch (Exception e)
{
if (_log.IsInfoEnabled)
{
_log.Info(
$"Failed to run merged transaction with {currentPendingOps.Count:#,#0} operations in async manner, will retry independently",
e);
}
using (previous)
using (context.Transaction)
{
if (calledCompletePreviousTx == false)
{
CompletePreviousTransaction(previous,
commitStats,
ref previousPendingOps,
// if this previous threw, it won't throw again
throwOnError: false);
}
else
{
throw;
}
}
NotifyTransactionFailureAndRerunIndependently(currentPendingOps, e);
return;
}
previous.Dispose();
switch (result)
{
case PendingOperations.CompletedAll:
try
{
context.Transaction.InnerTransaction.LowLevelTransaction.RetrieveCommitStats(out var stats);
context.Transaction.Commit();
SlowWriteNotification.Notify(stats, _parent);
context.Transaction.Dispose();
}
catch (Exception e)
{
foreach (var op in currentPendingOps)
{
op.Exception = e;
}
}
NotifyOnThreadPool(currentPendingOps);
return;
case PendingOperations.HasMore:
previousPendingOps = currentPendingOps;
previous = context.Transaction;
context.Transaction = null;
break;
default:
Debug.Assert(false);
return;
}
}
finally
{
context.Transaction?.Dispose();
}
}
}
finally
{
previous.Dispose();
}
}