private async Task <NexusConfig> GetSignatureKeyAsync(CancellationToken cancellationToken)
{
ApplicationSettings applicationSettings =
await _applicationSettingsStore.GetApplicationSettings(cancellationToken);
NexusConfig nexusConfig = applicationSettings.NexusConfig;
return(nexusConfig);
}
protected override async Task ExecuteAsync(CancellationToken stoppingToken)
{
await Task.Yield();
ApplicationSettings applicationSettings =
await _applicationSettingsStore.GetApplicationSettings(stoppingToken);
if (!applicationSettings.AutoDeploy.Enabled)
{
_logger.Debug("Auto deploy is disabled");
return;
}
if (!applicationSettings.AutoDeploy.PollingEnabled)
{
_logger.Debug("Auto deploy polling is disabled");
return;
}
await Task.Delay(TimeSpan.FromSeconds(_autoDeployConfiguration.StartupDelayInSeconds), stoppingToken);
while (!stoppingToken.IsCancellationRequested)
{
var deploymentTargets = await GetDeploymentTargetsWithAutoDeployEnabled(stoppingToken);
if (deploymentTargets.IsDefaultOrEmpty)
{
_logger.Verbose(
"Found no deployment targets with auto deployment enabled, waiting {DelayInSeconds} seconds",
_autoDeployConfiguration.EmptyTargetsDelayInSeconds);
await Task.Delay(
TimeSpan.FromSeconds(_autoDeployConfiguration.EmptyTargetsDelayInSeconds),
stoppingToken);
continue;
}
var targetsWithUrl = deploymentTargets.Where(target => target.Url is {}).ToImmutableArray();
protected override async Task ExecuteAsync(CancellationToken stoppingToken)
{
await Task.Yield();
ApplicationSettings applicationSettings =
await _applicationSettingsStore.GetApplicationSettings(stoppingToken);
if (!applicationSettings.HostAgentEnabled)
{
_logger.Information("Host agent is disabled");
return;
}
string?exePath = applicationSettings.AgentExe;
if (string.IsNullOrWhiteSpace(applicationSettings.AgentExe))
{
_logger.Debug("No agent exe has been specified");
var currentVersion = await GetCurrentVersionAsync();
NuGetPackageVersion nuGetPackageVersion = currentVersion is {}
public async Task Handle(PackageUpdatedEvent notification, CancellationToken cancellationToken)
{
if (!(await _applicationSettingsStore.GetApplicationSettings(cancellationToken)).AutoDeploy.Enabled)
{
_logger.Information("Auto deploy is disabled, skipping package web hook notification");
return;
}
PackageVersion packageIdentifier = notification.PackageVersion;
if (packageIdentifier is null)
{
throw new ArgumentException(nameof(packageIdentifier));
}
_logger.Information("Received hook for package {Package}", packageIdentifier);
IReadOnlyCollection <DeploymentTarget> deploymentTargets =
(await _targetSource.GetDeploymentTargetsAsync(stoppingToken: cancellationToken))
.SafeToReadOnlyCollection();
DeploymentTarget[] withAutoDeploy = deploymentTargets.Where(target => target.AutoDeployEnabled).ToArray();
if (!withAutoDeploy.Any())
{
_logger.Information("No target has auto deploy enabled");
}
else
{
foreach (DeploymentTarget deploymentTarget in withAutoDeploy)
{
if (deploymentTarget.PackageId.Equals(
packageIdentifier.PackageId,
StringComparison.OrdinalIgnoreCase))
{
if (deploymentTarget.NuGet.NuGetConfigFile is {} &&
public async Task <IReadOnlyCollection <PackageVersion> > GetPackageVersionsAsync(
string packageId,
bool useCache = true,
bool includePreReleased = false,
string?nugetPackageSource = null,
string?nugetConfigFile = null,
CancellationToken cancellationToken = default)
{
string cacheKey = GetCacheKey(nugetConfigFile, nugetPackageSource, packageId);
_logger.Verbose("Using package cache key {Key}", cacheKey);
if (useCache)
{
var packages = await _memoryCache.Get <PackageVersions>(cacheKey, _logger, cancellationToken);
_logger.Debug(
"Returning packages from cache with key {Key} for package id {PackageId}",
cacheKey,
packageId);
if (packages?.Versions.Length > 0)
{
return(packages.Versions
.Select(version => new PackageVersion(packageId, SemanticVersion.Parse(version)))
.ToImmutableArray());
}
}
var addedPackages = (await _packageService.GetPackageVersionsAsync(packageId, useCache,
includePreReleased, nugetPackageSource, nugetConfigFile, cancellationToken)).ToArray();
if (addedPackages.Length > 0)
{
ApplicationSettings settings =
await _applicationSettingsStore.GetApplicationSettings(CancellationToken.None);
var cacheTime = settings.CacheTime;
string[] versions = addedPackages
.Select(version => version.Version.ToNormalizedString())
.ToArray();
var packageVersions = new PackageVersions {
Versions = versions
};
await _memoryCache.Set(cacheKey, packageVersions, _logger, cancellationToken);
_logger.Debug(
"Cached {Packages} packages with key {CacheKey} for {Duration} seconds",
addedPackages.Length,
cacheKey,
cacheTime.TotalSeconds.ToString("F0", CultureInfo.InvariantCulture));
}
else
{
_logger.Debug("Added no packages to in-memory cache for cache key {CacheKey}", cacheKey);
}
return(addedPackages);
}
public async Task <AppVersion?> GetAppMetadataAsync(
[NotNull] DeploymentTarget target,
CancellationToken cancellationToken)
{
if (target is null)
{
throw new ArgumentNullException(nameof(target));
}
string cacheKey = GetCacheKey(target.Id);
if (_customMemoryCache.TryGetValue(cacheKey, out AppVersion? appMetadata))
{
_logger.Verbose("App metadata fetched from cache {CacheKey}", cacheKey);
return(appMetadata);
}
ApplicationSettings applicationSettings =
await _applicationSettingsStore.GetApplicationSettings(cancellationToken);
var targetMetadataTimeout = target.MetadataTimeout ?? applicationSettings.ApplicationSettingsCacheTimeout;
using (CancellationTokenSource cancellationTokenSource = _timeoutHelper.CreateCancellationTokenSource(
targetMetadataTimeout))
{
if (_logger.IsEnabled(LogEventLevel.Verbose))
{
cancellationTokenSource.Token.Register(() =>
{
_logger.Verbose(
"{Method} for {Target}, cancellation token invoked out after {Seconds} seconds",
nameof(GetAppMetadataAsync),
target,
targetMetadataTimeout.TotalSeconds.ToString("F1"));
});
}
using var linkedTokenSource =
CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, cancellationTokenSource.Token);
Task <(HttpResponseMessage?, string?)> metadataTask =
GetApplicationMetadataTask(target, linkedTokenSource.Token);
Task <IReadOnlyCollection <PackageVersion> > allowedPackagesTask =
GetAllowedPackagesAsync(target, linkedTokenSource.Token);
await Task.WhenAll(metadataTask, allowedPackagesTask);
(var response, string?message) = await metadataTask;
IReadOnlyCollection <PackageVersion> packages = await allowedPackagesTask;
if (response is null)
{
return(new AppVersion(
target,
message ?? $"Could not get application metadata from target {target.Url}, no response",
packages));
}
if (!response.IsSuccessStatusCode)
{
return(new AppVersion(
target,
message ??
$"Could not get application metadata from target {target.Url}, status code not successful {response.StatusCode}",
packages));
}
appMetadata =
await GetAppVersionAsync(response, target, packages, linkedTokenSource.Token);
response.Dispose();
}
if (appMetadata.SemanticVersion is { })