Skip to content
This repository was archived by the owner on Dec 5, 2024. It is now read-only.

Batching Repository Watcher #325

Merged
shana merged 7 commits into from
Sep 18, 2017
Merged

Batching Repository Watcher #325

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
7 commits
Select commit Hold shift + click to select a range
c4938ed
Batching events from the RepositoryWatcher
StanleyGoldman Sep 15, 2017
3b049e0
Hopefully making tests more reliable
StanleyGoldman Sep 15, 2017
6d68770
Merge branch 'fixes/locks-might-be-null' into fixes/batching-reposito…
StanleyGoldman Sep 15, 2017
ccc4d38
Tweaking the logs
StanleyGoldman Sep 15, 2017
80c1285
Additional optimizations
StanleyGoldman Sep 15, 2017
be017b6
Tweaking the way values are handled in CheckAndProcessEvents
StanleyGoldman Sep 15, 2017
b00b4d8
Merge branch 'master' into fixes/batching-repository-watcher
shana Sep 18, 2017
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
311 changes: 171 additions & 140 deletions src/GitHub.Api/Events/RepositoryWatcher.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -143,15 +143,32 @@ public int CheckAndProcessEvents()

signalProcessingEventsDone.Reset();
processingEvents = true;
lastCountOfProcessedEvents = 0;
var fileEvents = nativeInterface.GetEvents();
var processedEventCount = 0;

var fileEvents = nativeInterface.GetEvents();
if (fileEvents.Length > 0)
{
Logger.Trace("Processing {0} Events", fileEvents.Length);
Logger.Trace("Handling {0} Events", fileEvents.Length);
processedEventCount = ProcessEvents(fileEvents);
Logger.Trace("Processed {0} Events", processedEventCount);
}

lastCountOfProcessedEvents = processedEventCount;
processingEvents = false;
signalProcessingEventsDone.Set();

return processedEventCount;
}

private int ProcessEvents(Event[] fileEvents)
{
var eventsProcessed = 0;
var configChanged = false;
var headChanged = false;
var repositoryChanged = false;
var indexChanged = false;

string headContent = null;

foreach (var fileEvent in fileEvents)
{
Expand Down Expand Up @@ -180,176 +197,190 @@ public int CheckAndProcessEvents()
// handling events in .git/*
if (fileA.IsChildOf(paths.DotGitPath))
{
HandleEventInDotGit(fileEvent, fileA, fileB);
}
else
{
if (repositoryChanged || ignoredPaths.Any(ignoredPath => fileA.IsChildOf(ignoredPath)))
if (!configChanged && fileA.Equals(paths.DotGitConfig))
{
continue;
configChanged = true;
}

repositoryChanged = true;
}
lastCountOfProcessedEvents++;
}

if (repositoryChanged)
{
Logger.Trace("RepositoryChanged");
RepositoryChanged?.Invoke();
}

processingEvents = false;
signalProcessingEventsDone.Set();
return lastCountOfProcessedEvents;
}

private void HandleEventInDotGit(Event fileEvent, NPath fileA, NPath fileB = null)
{
if (fileA.Equals(paths.DotGitConfig))
{
Logger.Trace("ConfigChanged");

ConfigChanged?.Invoke();
}
else if (fileA.Equals(paths.DotGitHead))
{
string headContent = null;
if (fileEvent.Type != EventType.DELETED)
{
headContent = paths.DotGitHead.ReadAllLines().FirstOrDefault();
}

Logger.Trace("HeadChanged: {0}", headContent ?? "[null]");
HeadChanged?.Invoke(headContent);
}
else if (fileA.Equals(paths.DotGitIndex))
{
Logger.Trace("IndexChanged");
IndexChanged?.Invoke();
}
else if (fileA.IsChildOf(paths.RemotesPath))
{
var relativePath = fileA.RelativeTo(paths.RemotesPath);
var relativePathElements = relativePath.Elements.ToArray();

if (!relativePathElements.Any())
{
return;
}

var origin = relativePathElements[0];

if (fileEvent.Type == EventType.DELETED)
{
if (fileA.ExtensionWithDot == ".lock")
else if (!headChanged && fileA.Equals(paths.DotGitHead))
{
return;
}

var branch = string.Join(@"/", relativePathElements.Skip(1).ToArray());
if (fileEvent.Type != EventType.DELETED)
{
headContent = paths.DotGitHead.ReadAllLines().FirstOrDefault();
}

Logger.Trace("RemoteBranchDeleted: {0}/{1}", origin, branch);
RemoteBranchDeleted?.Invoke(origin, branch);
}
else if (fileEvent.Type == EventType.RENAMED)
{
if (fileA.ExtensionWithDot != ".lock")
headChanged = true;
}
else if (!indexChanged && fileA.Equals(paths.DotGitIndex))
{
return;
indexChanged = true;
}

if (fileB != null && fileB.FileExists())
else if (fileA.IsChildOf(paths.RemotesPath))
{
if (fileA.FileNameWithoutExtension == fileB.FileNameWithoutExtension)
{
var branchPathElement = relativePathElements.Skip(1)
.Take(relativePathElements.Length-2)
.Union(new [] { fileA.FileNameWithoutExtension }).ToArray();

var branch = string.Join(@"/", branchPathElement);
var relativePath = fileA.RelativeTo(paths.RemotesPath);
var relativePathElements = relativePath.Elements.ToArray();

Logger.Trace("RemoteBranchCreated: {0}/{1}", origin, branch);
RemoteBranchCreated?.Invoke(origin, branch);
if (!relativePathElements.Any())
{
continue;
}
}
}
}
else if (fileA.IsChildOf(paths.BranchesPath))
{
if (fileEvent.Type == EventType.MODIFIED)
{
if (fileA.DirectoryExists())
{
return;
}

if (fileA.ExtensionWithDot == ".lock")
{
return;
}
var origin = relativePathElements[0];

var relativePath = fileA.RelativeTo(paths.BranchesPath);
var relativePathElements = relativePath.Elements.ToArray();
if (fileEvent.Type == EventType.DELETED)
{
if (fileA.ExtensionWithDot == ".lock")
{
continue;
}

if (!relativePathElements.Any())
{
return;
}
var branch = string.Join(@"/", relativePathElements.Skip(1).ToArray());

var branch = string.Join(@"/", relativePathElements.ToArray());
Logger.Trace("RemoteBranchDeleted: {0}/{1}", origin, branch);
RemoteBranchDeleted?.Invoke(origin, branch);
eventsProcessed++;
}
else if (fileEvent.Type == EventType.RENAMED)
{
if (fileA.ExtensionWithDot != ".lock")
{
continue;
}

Logger.Trace("LocalBranchChanged: {0}", branch);
LocalBranchChanged?.Invoke(branch);
}
else if (fileEvent.Type == EventType.DELETED)
{
if (fileA.ExtensionWithDot == ".lock")
{
return;
if (fileB != null && fileB.FileExists())
{
if (fileA.FileNameWithoutExtension == fileB.FileNameWithoutExtension)
{
var branchPathElement = relativePathElements
.Skip(1).Take(relativePathElements.Length - 2)
.Union(new[] { fileA.FileNameWithoutExtension }).ToArray();

var branch = string.Join(@"/", branchPathElement);

Logger.Trace("RemoteBranchCreated: {0}/{1}", origin, branch);
RemoteBranchCreated?.Invoke(origin, branch);
eventsProcessed++;
}
}
}
}
else if (fileA.IsChildOf(paths.BranchesPath))
{
if (fileEvent.Type == EventType.MODIFIED)
{
if (fileA.DirectoryExists())
{
continue;
}

var relativePath = fileA.RelativeTo(paths.BranchesPath);
var relativePathElements = relativePath.Elements.ToArray();
if (fileA.ExtensionWithDot == ".lock")
{
continue;
}

if (!relativePathElements.Any())
{
return;
}
var relativePath = fileA.RelativeTo(paths.BranchesPath);
var relativePathElements = relativePath.Elements.ToArray();

var branch = string.Join(@"/", relativePathElements.ToArray());
if (!relativePathElements.Any())
{
continue;
}

Logger.Trace("LocalBranchDeleted: {0}", branch);
LocalBranchDeleted?.Invoke(branch);
}
else if (fileEvent.Type == EventType.RENAMED)
{
if (fileA.ExtensionWithDot != ".lock")
{
return;
}
var branch = string.Join(@"/", relativePathElements.ToArray());

if (fileB != null && fileB.FileExists())
{
if (fileA.FileNameWithoutExtension == fileB.FileNameWithoutExtension)
Logger.Trace("LocalBranchChanged: {0}", branch);
LocalBranchChanged?.Invoke(branch);
eventsProcessed++;
}
else if (fileEvent.Type == EventType.DELETED)
{
var relativePath = fileB.RelativeTo(paths.BranchesPath);
if (fileA.ExtensionWithDot == ".lock")
{
continue;
}

var relativePath = fileA.RelativeTo(paths.BranchesPath);
var relativePathElements = relativePath.Elements.ToArray();

if (!relativePathElements.Any())
{
return;
continue;
}

var branch = string.Join(@"/", relativePathElements.ToArray());

Logger.Trace("LocalBranchCreated: {0}", branch);
LocalBranchCreated?.Invoke(branch);
Logger.Trace("LocalBranchDeleted: {0}", branch);
LocalBranchDeleted?.Invoke(branch);
eventsProcessed++;
}
else if (fileEvent.Type == EventType.RENAMED)
{
if (fileA.ExtensionWithDot != ".lock")
{
continue;
}

if (fileB != null && fileB.FileExists())
{
if (fileA.FileNameWithoutExtension == fileB.FileNameWithoutExtension)
{
var relativePath = fileB.RelativeTo(paths.BranchesPath);
var relativePathElements = relativePath.Elements.ToArray();

if (!relativePathElements.Any())
{
continue;
}

var branch = string.Join(@"/", relativePathElements.ToArray());

Logger.Trace("LocalBranchCreated: {0}", branch);
LocalBranchCreated?.Invoke(branch);
eventsProcessed++;
}
}
}
}
}
else
{
if (repositoryChanged || ignoredPaths.Any(ignoredPath => fileA.IsChildOf(ignoredPath)))
{
continue;
}

repositoryChanged = true;
}
}

if (configChanged)
{
Logger.Trace("ConfigChanged");
ConfigChanged?.Invoke();
eventsProcessed++;
}

if (headChanged)
{
Logger.Trace("HeadChanged: {0}", headContent ?? "[null]");
HeadChanged?.Invoke(headContent);
eventsProcessed++;
}

if (indexChanged)
{
Logger.Trace("IndexChanged");
IndexChanged?.Invoke();
eventsProcessed++;
}

if (repositoryChanged)
{
Logger.Trace("RepositoryChanged");
RepositoryChanged?.Invoke();
eventsProcessed++;
}

return eventsProcessed;
}

private bool disposed;
Expand Down
Loading