public override void PrintHeader(string workflowName, string fileName) =>
_streamer.PushLine <ColorActionPrinter>(new StreamOptions
{
Level = LogLevel.Information,
Messages = new StreamMessageBuilder()
.Add($"> {workflowName} ({fileName})", FOREGROUND_COLOR_INFO).Build()
});
public async Task <string> GetLatestVersionAsync(string owner, string repository)
{
string key = $"{owner}/{repository}";
if (LocalCache.ContainsKey(key))
{
_streamer.PushLine <MemoryCacheVersionProvider>(new StreamOptions
{
Level = LogLevel.Debug,
Messages = new StreamMessageBuilder()
.Add($"{owner}/{repository} latest release is retrieved from cache").Build()
});
}
else
{
await _semaphore.WaitAsync();
try
{
if (!LocalCache.ContainsKey(key))
{
LocalCache.Add(key, _provider.GetLatestVersionAsync(owner, repository));
}
}
finally
{
_semaphore.Release();
}
}
return(await LocalCache[key]);
}
public async Task <string> GetLatestVersionAsync(string owner, string repository)
{
using ILiteDatabase db = _databaseFactory(GetDbFilePath());
string actionName = $"{owner}/{repository}";
ILiteCollection <ActionDto> actions = db.GetCollection <ActionDto>(ACTIONS_COLLECTION);
ActionDto actionDto = actions.FindById(actionName);
if (actionDto == null)
{
actionDto = new ActionDto
{
Name = actionName,
Version = await _provider.GetLatestVersionAsync(owner, repository),
Timestamp = DateTime.Now
};
actions.Insert(actionName, actionDto);
}
else if (DateTime.Now.Subtract(actionDto.Timestamp) > _storageTime)
{
actionDto.Version = await _provider.GetLatestVersionAsync(owner, repository);
actionDto.Timestamp = DateTime.Now;
actions.Update(actionName, actionDto);
}
else
{
_streamer.PushLine <DbCacheVersionProvider>(new StreamOptions
{
Level = LogLevel.Debug,
Messages = new StreamMessageBuilder()
.Add($"{owner}/{repository} version is retrieved from local DB").Build()
});
}
return(actionDto.Version);
}
public async Task <string> GetLatestVersionAsync(string owner, string repository)
{
Exception lastException = null;
string tagName = null;
try
{
_streamer.PushLine <GitHubVersionProvider>(new StreamOptions
{
Level = LogLevel.Debug,
Messages = new StreamMessageBuilder()
.Add($"Getting latest release for {owner}/{repository}...").Build()
});
tagName = await _client.GetLatestReleaseVersionAsync(owner, repository);
}
catch (NotFoundException)
{
try
{
_streamer.PushLine <GitHubVersionProvider>(new StreamOptions
{
Level = LogLevel.Debug,
Messages = new StreamMessageBuilder()
.Add($"{owner}/{repository} release is not found. Getting latest tag...").Build()
});
tagName = await _client.GetLatestTagVersionAsync(owner, repository);
}
catch (Exception e)
{
lastException = e;
}
}
catch (Exception e)
{
lastException = e;
}
string errorMessage = $"{owner}/{repository} version is not found.";
if (lastException != null)
{
_streamer.PushLine <GitHubVersionProvider>(new StreamOptions
{
Exception = lastException,
Level = LogLevel.Error,
Messages = new StreamMessageBuilder().Add(lastException.Message, ConsoleColor.Red).Build()
});
throw new GitHubVersionNotFoundException(errorMessage, lastException);
}
if (tagName == null)
{
throw new GitHubVersionNotFoundException(errorMessage);
}
_streamer.PushLine <GitHubVersionProvider>(new StreamOptions
{
Level = LogLevel.Debug,
Messages = new StreamMessageBuilder().Add($"{owner}/{repository} latest release is {tagName}").Build()
});
return(tagName);
}
public IDictionary <WorkflowInfo, IEnumerable <GitHubAction> > GetOutdated(IEnumerable <WorkflowInfo> items)
{
int totalCount = items
.SelectMany(wfi => wfi.Workflow.Jobs)
.SelectMany(j => j.Value.Steps)
.Count(s => s.Action.IsValidForUpgrade);
OnRepositoryCheckedStarted(totalCount);
var index = 0;
Dictionary <WorkflowInfo, IEnumerable <GitHubAction> > result = items
.AsParallel()
.ToDictionary(
wfi => wfi,
wfi => wfi.Workflow.Jobs
.SelectMany(job => job.Value.Steps)
.AsParallel()
.Select(step => step.Action)
.Where(action => action.IsValidForUpgrade)
.Select(async action =>
{
if (action.LatestVersion == null)
{
await _semaphore.WaitAsync();
try
{
if (action.LatestVersion == null)
{
OnRepositoryChecked(++index, totalCount);
action.LatestVersion = await _provider.GetLatestVersionAsync(action.Owner, action.Repository);
}
}
catch (GitHubVersionNotFoundException e)
{
_streamer.PushLine <GitHubService>(new StreamOptions
{
Exception = e,
Level = LogLevel.Warning,
Messages = new StreamMessageBuilder().Add(e.Message, ConsoleColor.Yellow).Build()
});
}
catch (Exception e)
{
_streamer.PushLine <GitHubService>(new StreamOptions
{
Exception = e,
Level = LogLevel.Error,
Messages = new StreamMessageBuilder().Add(e.Message, ConsoleColor.Red).Build()
});
}
finally
{
_semaphore.Release();
}
}
return(action);
})
.Select(t => t.Result)
.Where(action => !action.IsUpToDate))
.Where(p => p.Value.Any())
.ToDictionary(p => p.Key, p => p.Value.AsEnumerable());
OnRepositoryCheckedFinished();
return(result);
}
