private async Task <DependencyGraphNode> BuildGraphAtDependency(
IRemoteFactory remoteFactory,
DependencyDetail rootDependency,
List <DependencyDetail> updateList,
Dictionary <string, DependencyGraphNode> nodeCache)
{
DependencyGraphBuildOptions dependencyGraphBuildOptions = new DependencyGraphBuildOptions()
{
IncludeToolset = true,
LookupBuilds = true,
NodeDiff = NodeDiff.None,
EarlyBuildBreak = new EarlyBreakOn
{
Type = EarlyBreakOnType.Assets,
BreakOn = new List <string>(updateList.Select(d => d.Name))
}
};
DependencyGraph dependencyGraph = await DependencyGraph.BuildRemoteDependencyGraphAsync(
remoteFactory, null, rootDependency.RepoUri, rootDependency.Commit, dependencyGraphBuildOptions, _logger);
// Cache all nodes in this built graph.
foreach (DependencyGraphNode node in dependencyGraph.Nodes)
{
if (!nodeCache.ContainsKey($"{node.Repository}@{node.Commit}"))
{
nodeCache.Add($"{node.Repository}@{node.Commit}", node);
}
}
return(dependencyGraph.Root);
}
static void Main(string[] args)
{
Console.WriteLine("Configuring client...");
RemotingConfiguration.Configure("ConsoleClient.exe.config");
Console.WriteLine("Creating proxy...");
IRemoteFactory factory = (IRemoteFactory)RemotingHelper.CreateProxy(typeof(IRemoteFactory));
Console.WriteLine("Calling GetAge()...");
int age = factory.GetAge();
Console.WriteLine(">> Call successful: " + age.ToString());
Console.WriteLine("Calling GetPerson()...");
Person p = factory.GetPerson();
Console.WriteLine(">> Person retrieved: {0} {1}, {2}", p.Firstname, p.Lastname, p.Age.ToString());
Console.WriteLine(">>>> New properties: {0} {1}", p.Birthdate, p.Comments);
Console.WriteLine("Calling UploadPerson()...");
Person up = new Person("Upload", "Test", 20);
up.Birthdate = DateTime.Now.AddDays(2);
up.Comments = "Two days older person!";
factory.UploadPerson(up);
Console.WriteLine(">> Upload called successfully!");
Console.ReadLine();
}
public BuildTimeController(
ILogger <BuildTimeController> logger,
IRemoteFactory remoteFactory)
{
_logger = logger;
_remoteFactory = remoteFactory;
}
private async Task CoherencyUpdatesAsync(
IRemote barOnlyRemote,
IRemoteFactory remoteFactory,
List <DependencyDetail> currentDependencies,
List <DependencyDetail> dependenciesToUpdate)
{
Console.WriteLine("Checking for coherency updates...");
// Now run a coherency update based on the current set of dependencies updated
// from the previous pass.
List <DependencyUpdate> coherencyUpdates =
await barOnlyRemote.GetRequiredCoherencyUpdatesAsync(currentDependencies, remoteFactory);
foreach (DependencyUpdate dependencyUpdate in coherencyUpdates)
{
DependencyDetail from = dependencyUpdate.From;
DependencyDetail to = dependencyUpdate.To;
DependencyDetail coherencyParent = currentDependencies.First(d =>
d.Name.Equals(from.CoherentParentDependencyName, StringComparison.OrdinalIgnoreCase));
// Print out what we are going to do.
Console.WriteLine($"Updating '{from.Name}': '{from.Version}' => '{to.Version}' " +
$"to ensure coherency with {from.CoherentParentDependencyName}@{coherencyParent.Version}");
// Final list of dependencies to update
dependenciesToUpdate.Add(to);
}
}
static void Main(string[] args)
{
HttpChannel channel = new HttpChannel();
ChannelServices.RegisterChannel(channel);
Console.WriteLine("Acqu. Rem. Instance");
IRemoteFactory fact = (IRemoteFactory)Activator.GetObject(
typeof(IRemoteFactory),
"http://localhost:1234/factory.soap");
Console.WriteLine("Client.Main(): Acquiring object from factory");
IRemoteObject obj1 = fact.getNewInstance();
Console.WriteLine("Client.Main(): Sleeping one second");
System.Threading.Thread.Sleep(1000);
Console.WriteLine("Client.Main(): Setting value");
try
{
obj1.setValue(42);
}
catch (Exception e)
{
Console.WriteLine("Client.Main(). EXCEPTION \n{0}", e.Message);
}
Console.ReadLine();
}
public SecondServer()
{
System.Diagnostics.Debug.WriteLine("Initializing server...");
_proxy = (IRemoteFactory)RemotingHelper.CreateProxy(typeof(IRemoteFactory));
System.Diagnostics.Debug.WriteLine("Server initialized!");
}
private void ActionCall_Click(object sender, System.EventArgs e)
{
IRemoteFactory proxy = (IRemoteFactory)RemotingHelper.CreateProxy(typeof(IRemoteFactory));
Person p = proxy.GetPerson();
ListResults.Items.Add(string.Format("{0} {1}, {2}",
p.Firstname, p.Lastname, p.Age));
}
public ChannelsController(BuildAssetRegistryContext context,
IRemoteFactory factory,
ILogger <ChannelsController> logger)
{
_context = context;
_remoteFactory = factory;
Logger = logger;
}
private static async Task DoLatestInChannelGraphNodeDiffAsync(
IRemoteFactory remoteFactory,
ILogger logger,
Dictionary <string, DependencyGraphNode> nodeCache,
Dictionary <string, DependencyGraphNode> visitedRepoUriNodes)
{
logger.LogInformation("Running latest in channel node diff.");
IRemote barOnlyRemote = await remoteFactory.GetBarOnlyRemoteAsync(logger);
// Walk each node in the graph and diff against the latest build in the channel
// that was also applied to the node.
Dictionary <string, string> latestCommitCache = new Dictionary <string, string>();
foreach (DependencyGraphNode node in nodeCache.Values)
{
// Start with an unknown diff.
node.DiffFrom = GitDiff.UnknownDiff();
if (node.ContributingBuilds.Any())
{
// Choose latest build of node that has a channel.
Build newestBuildWithChannel = node.ContributingBuilds.OrderByDescending(b => b.DateProduced).FirstOrDefault(
b => b.Channels != null && b.Channels.Any());
// If no build was found (e.g. build was flowed without a channel or channel was removed from
// a build, then no diff from latest.
if (newestBuildWithChannel != null)
{
int channelId = newestBuildWithChannel.Channels.First().Id;
// Just choose the first channel. This algorithm is mostly just heuristic.
string latestCommitKey = $"{node.Repository}@{channelId}";
string latestCommit = null;
if (!latestCommitCache.TryGetValue(latestCommitKey, out latestCommit))
{
// Look up latest build in the channel
var latestBuild = await barOnlyRemote.GetLatestBuildAsync(node.Repository, channelId);
// Could be null, if the only build was removed from the channel
if (latestBuild != null)
{
latestCommit = latestBuild.Commit;
}
// Add to cache
latestCommitCache.Add(latestCommitKey, latestCommit);
}
// Perform diff if there is a latest commit.
if (!string.IsNullOrEmpty(latestCommit))
{
IRemote repoRemote = await remoteFactory.GetRemoteAsync(node.Repository, logger);
// This will return a no-diff if latestCommit == node.Commit
node.DiffFrom = await repoRemote.GitDiffAsync(node.Repository, latestCommit, node.Commit);
}
}
}
}
}
private void ActionCall_Click(object sender, System.EventArgs e)
{
// Get the transparent proxy for the factory
IRemoteFactory proxy = WinApplication.ServerProxy;
Person p = proxy.GetPerson();
TextResults.AppendText(
string.Format("{0} {1}, {2}\r\n", p.Firstname, p.Lastname, p.Age));
}
public BuildsController(
BuildAssetRegistryContext context,
IBackgroundQueue queue,
ISystemClock clock,
IRemoteFactory factory)
: base(context, clock)
{
Queue = queue;
Factory = factory;
}
private async Task <int> CoherencyUpdatesAsync(
IRemote barOnlyRemote,
IRemoteFactory remoteFactory,
List <DependencyDetail> currentDependencies,
List <DependencyDetail> dependenciesToUpdate)
{
Console.WriteLine("Checking for coherency updates...");
CoherencyMode coherencyMode = CoherencyMode.Legacy;
if (_options.StrictCoherency)
{
coherencyMode = CoherencyMode.Strict;
}
List <DependencyUpdate> coherencyUpdates = null;
try
{
// Now run a coherency update based on the current set of dependencies updated
// from the previous pass.
coherencyUpdates = await barOnlyRemote.GetRequiredCoherencyUpdatesAsync(
currentDependencies, remoteFactory, coherencyMode);
}
catch (DarcCoherencyException e)
{
Console.WriteLine("Coherency updates failed for the following dependencies:");
foreach (var error in e.Errors)
{
Console.WriteLine($" Unable to update {error.Dependency.Name} to have coherency with " +
$"{error.Dependency.CoherentParentDependencyName}: {error.Error}");
foreach (string potentialSolution in error.PotentialSolutions)
{
Console.WriteLine($" - {potentialSolution}");
}
}
return(Constants.ErrorCode);
}
foreach (DependencyUpdate dependencyUpdate in coherencyUpdates)
{
DependencyDetail from = dependencyUpdate.From;
DependencyDetail to = dependencyUpdate.To;
DependencyDetail coherencyParent = currentDependencies.First(d =>
d.Name.Equals(from.CoherentParentDependencyName, StringComparison.OrdinalIgnoreCase));
// Print out what we are going to do.
Console.WriteLine($"Updating '{from.Name}': '{from.Version}' => '{to.Version}' " +
$"to ensure coherency with {from.CoherentParentDependencyName}@{coherencyParent.Version}");
// Final list of dependencies to update
dependenciesToUpdate.Add(to);
}
return(Constants.SuccessCode);
}
public PullRequestPolicyFailureNotifier(
IGitHubTokenProvider gitHubTokenProvider,
IGitHubClientFactory gitHubClientFactory,
IRemoteFactory darcFactory,
ILogger <PullRequestPolicyFailureNotifier> logger)
{
Logger = logger;
GitHubTokenProvider = gitHubTokenProvider;
GitHubClientFactory = gitHubClientFactory;
DarcRemoteFactory = darcFactory;
}
public BuildsController(BuildAssetRegistryContext context,
IRemoteFactory factory,
IServiceScopeFactory serviceScopeFactory,
BackgroundQueue queue,
ILogger <BuildsController> logger)
: base(context)
{
RemoteFactory = factory;
ServiceScopeFactory = serviceScopeFactory;
Queue = queue;
Logger = logger;
}
/// <summary>
/// Diff each node in the graph against the latest build in
/// the graph.
/// </summary>
/// <param name="remoteFactory"></param>
/// <param name="logger"></param>
/// <param name="nodeCache"></param>
/// <param name="visitedRepoUriNodes"></param>
/// <returns></returns>
private static async Task DoLatestInGraphNodeDiffAsync(
IRemoteFactory remoteFactory,
ILogger logger,
Dictionary <string, DependencyGraphNode> nodeCache,
Dictionary <string, DependencyGraphNode> visitedRepoUriNodes)
{
logger.LogInformation("Running latest in graph node diff.");
// Find the build of each repo in the graph, then
// get the diff info from the latest
foreach (string repo in visitedRepoUriNodes.Keys)
{
// Get all nodes with this value
List <DependencyGraphNode> nodes = nodeCache.Values.Where(n => n.Repository == repo).ToList();
// If only one, determine latest
if (nodes.Count > 1)
{
// Find latest
DependencyGraphNode newestNode = null;
Build newestBuild = null;
foreach (DependencyGraphNode node in nodes)
{
if (newestNode == null)
{
newestNode = node;
if (newestNode.ContributingBuilds.Any())
{
newestBuild = newestNode.ContributingBuilds.OrderByDescending(b => b.DateProduced).First();
}
}
else if (node.ContributingBuilds.Any(b => b.DateProduced > newestBuild?.DateProduced))
{
newestNode = node;
newestBuild = newestNode.ContributingBuilds.OrderByDescending(b => b.DateProduced).First();
}
}
// Compare all other nodes to the latest
foreach (DependencyGraphNode node in nodes)
{
IRemote repoRemote = await remoteFactory.GetRemoteAsync(node.Repository, logger);
// If node == newestNode, returns no diff.
node.DiffFrom = await repoRemote.GitDiffAsync(node.Repository, newestNode.Commit, node.Commit);
}
}
else
{
DependencyGraphNode singleNode = nodes.Single();
singleNode.DiffFrom = GitDiff.NoDiff(singleNode.Commit);
}
}
}
static void Main(string[] args)
{
System.Console.WriteLine("Configuring client...");
RemotingConfiguration.Configure("ConsoleClient.exe.config");
System.Console.WriteLine("Calling server 1...");
IRemoteFactory factory = (IRemoteFactory)RemotingHelper.CreateProxy(typeof(IRemoteFactory));
Person p = factory.GetPerson();
System.Console.WriteLine(">> Person retrieved: {0} {1}, {2}", p.Firstname, p.Lastname, p.Age.ToString());
System.Console.WriteLine();
}
/// <summary>
/// Given a repo and branch, determine what updates are required to satisfy
/// coherency constraints.
/// </summary>
/// <param name="repoUri">Repository uri to check for updates in.</param>
/// <param name="branch">Branch to check for updates in.</param>
/// <param name="remoteFactory">Remote factory use in walking the repo dependency graph.</param>
/// <returns>List of dependencies requiring updates (with updated info).</returns>
public async Task <List <DependencyUpdate> > GetRequiredCoherencyUpdatesAsync(
string repoUri,
string branch,
IRemoteFactory remoteFactory)
{
CheckForValidGitClient();
_logger.LogInformation($"Determining required coherency updates in {repoUri}@{branch}...");
IEnumerable <DependencyDetail> currentDependencies =
await _fileManager.ParseVersionDetailsXmlAsync(repoUri, branch);
return(await GetRequiredCoherencyUpdatesAsync(currentDependencies, remoteFactory));
}
public DependencyUpdater(
IReliableStateManager stateManager,
ILogger <DependencyUpdater> logger,
BuildAssetRegistryContext context,
IRemoteFactory factory,
IActorProxyFactory <ISubscriptionActor> subscriptionActorFactory)
{
StateManager = stateManager;
Logger = logger;
Context = context;
RemoteFactory = factory;
SubscriptionActorFactory = subscriptionActorFactory;
}
static void Main(string[] args)
{
System.Console.WriteLine("Configuring client...");
RemotingConfiguration.Configure("ConsoleClient.exe.config");
System.Console.WriteLine("Creating proxy...");
IRemoteFactory factory = (IRemoteFactory)RemotingHelper.CreateProxy(typeof(IRemoteFactory));
System.Console.WriteLine("Calling UploadPerson()...");
factory.UploadPerson(new Person("Test", "Upload", 24));
System.Console.WriteLine(">> Upload called successfully!");
System.Console.ReadLine();
}
static void Main(string[] args)
{
String filename = AppDomain.CurrentDomain.SetupInformation.ConfigurationFile;
RemotingConfiguration.Configure(filename);
IRemoteFactory fact = (IRemoteFactory)RemotingHelper.CreateProxy(typeof(IRemoteFactory));
IRemoteObject cao = fact.CreateInstance();
IRemoteSponsorFactory sf = (IRemoteSponsorFactory)RemotingHelper.CreateProxy(typeof(IRemoteSponsorFactory));
InstanceSponsor sp = sf.CreateSponsor();
EnsureKeepAlive keepalive = new EnsureKeepAlive(sp);
ILease le = (ILease)((MarshalByRefObject)cao).GetLifetimeService();
le.Register(sp);
try
{
Console.WriteLine("{0} CLIENT: Calling DoSomething()", DateTime.Now);
cao.DoSomething();
}
catch (Exception e)
{
Console.WriteLine(" --> EX: Timeout in first call\n{0}", e.Message);
}
Console.WriteLine("{0} CLIENT: Sleeping for 6 seconds", DateTime.Now);
Thread.Sleep(6000);
try
{
Console.WriteLine("{0} CLIENT: Calling DoSomething()", DateTime.Now);
cao.DoSomething();
}
catch (Exception e)
{
Console.WriteLine(" --> EX: Timeout in second call\n{0}", e.Message);
}
Console.WriteLine("{0} CLIENT: Unregistering sponsor", DateTime.Now);
le.Unregister(sp);
keepalive.StopKeepAlive();
Console.WriteLine("Finished ... press <return> to exit");
Console.ReadLine();
Console.ReadLine();
}
static void Main(string[] args)
{
HttpChannel channel = new HttpChannel();
ChannelServices.RegisterChannel(channel);
Console.WriteLine("Client.Main(): Creating factory");
IRemoteFactory fact = (IRemoteFactory)Activator.GetObject(
typeof(IRemoteFactory),
"http://localhost:1235/factory.soap");
IRemoteObject obj1 = fact.GetNewInstance();
Console.WriteLine("Done");
Console.ReadLine();
}
/// <summary>
/// Builds a dependency graph given a root repo and commit using remotes.
/// </summary>
/// <param name="remoteFactory">Factory that can create remotes based on repo uris</param>
/// <param name="repoUri">Root repository URI</param>
/// <param name="commit">Root commit</param>
/// <param name="options">Graph build options.</param>
/// <param name="logger">Logger</param>
/// <returns>New dependency graph.</returns>
public static async Task <DependencyGraph> BuildRemoteDependencyGraphAsync(
IRemoteFactory remoteFactory,
string repoUri,
string commit,
DependencyGraphBuildOptions options,
ILogger logger)
{
return(await BuildDependencyGraphImplAsync(
remoteFactory,
null, /* no initial root dependencies */
repoUri,
commit,
options,
true,
logger,
null,
null,
null));
}
/// <summary>
/// Validate that the graph build options are correct.
/// </summary>
/// <param name="remoteFactory"></param>
/// <param name="rootDependencies"></param>
/// <param name="repoUri"></param>
/// <param name="commit"></param>
/// <param name="options"></param>
/// <param name="remote"></param>
/// <param name="logger"></param>
/// <param name="reposFolder"></param>
/// <param name="remotesMap"></param>
/// <param name="testPath"></param>
private static void ValidateBuildOptions(
IRemoteFactory remoteFactory,
IEnumerable <DependencyDetail> rootDependencies,
string repoUri,
string commit,
DependencyGraphBuildOptions options,
bool remote,
ILogger logger,
string reposFolder,
IEnumerable <string> remotesMap,
string testPath)
{
// Fail fast if darcSettings is null in a remote scenario
if (remote && remoteFactory == null)
{
throw new DarcException("Remote graph build requires a remote factory.");
}
if (rootDependencies != null && !rootDependencies.Any())
{
throw new DarcException("Root dependencies were not supplied.");
}
if (!remote)
{
if (options.LookupBuilds)
{
throw new DarcException("Build lookup only available in remote build mode.");
}
if (options.NodeDiff != NodeDiff.None)
{
throw new DarcException($"Node diff type '{options.NodeDiff}' only available in remote build mode.");
}
}
else
{
if (options.NodeDiff != NodeDiff.None && !options.LookupBuilds)
{
throw new DarcException("Node diff requires build lookup.");
}
}
}
/// <summary>
/// Builds a dependency graph given a root repo and commit.
/// </summary>
/// <param name="remoteFactory">Factory that can create remotes based on repo uris</param>
/// <param name="rootDependencies">Root set of dependencies</param>
/// <param name="repoUri">Root repository URI</param>
/// <param name="commit">Root commit</param>
/// <param name="options">Graph build options.</param>
/// <param name="logger">Logger</param>
/// <returns>New dependency graph.</returns>
public static async Task <DependencyGraph> BuildRemoteDependencyGraphAsync(
IRemoteFactory remoteFactory,
IEnumerable <DependencyDetail> rootDependencies,
string repoUri,
string commit,
DependencyGraphBuildOptions options,
ILogger logger)
{
return(await BuildDependencyGraphImplAsync(
remoteFactory,
rootDependencies,
repoUri,
commit,
options,
true,
logger,
null,
null,
null));
}
protected PullRequestActorImplementation(
ActorId id,
IReminderManager reminders,
IActorStateManager stateManager,
IMergePolicyEvaluator mergePolicyEvaluator,
BuildAssetRegistryContext context,
IRemoteFactory darcFactory,
ILoggerFactory loggerFactory,
IActionRunner actionRunner,
Func <ActorId, ISubscriptionActor> subscriptionActorFactory)
{
Id = id;
Reminders = reminders;
StateManager = stateManager;
MergePolicyEvaluator = mergePolicyEvaluator;
Context = context;
DarcRemoteFactory = darcFactory;
ActionRunner = actionRunner;
SubscriptionActorFactory = subscriptionActorFactory;
Logger = loggerFactory.CreateLogger(TypeNameHelper.GetTypeDisplayName(GetType()));
}
static void Main(string[] args)
{
Console.WriteLine("Configuring client...");
RemotingConfiguration.Configure("ConsoleClient.exe.config");
Console.WriteLine("Creating proxy...");
IRemoteFactory factory = (IRemoteFactory)RemotingHelper.CreateProxy(typeof(IRemoteFactory));
Console.WriteLine("Calling GetAge()...");
int age = factory.GetAge();
Console.WriteLine(">> Call successful: " + age.ToString());
Console.WriteLine("Calling GetPerson()...");
Person p = factory.GetPerson();
Console.WriteLine(">> Person retrieved: {0} {1}, {2}", p.Firstname, p.Lastname, p.Age.ToString());
Console.WriteLine("Calling UploadPerson()...");
factory.UploadPerson(new Person("Upload", "Test", 20));
Console.WriteLine(">> Upload called successfully!");
Console.ReadLine();
}
static void Main(string[] args)
{
HttpChannel channel = new HttpChannel();
ChannelServices.RegisterChannel(channel);
Console.WriteLine("Client.Main(): Creating factory");
IRemoteFactory fact = (IRemoteFactory)Activator.GetObject(
typeof(IRemoteFactory),
"http://localhost:1234/factory.soap");
Console.WriteLine("Client.Main(): Acquiring first object from factory");
IRemoteObject obj1 = fact.getNewInstance();
obj1.setValue(42);
Console.WriteLine("Client.Main(): Acquiring second object from factory");
IRemoteObject obj2 = fact.getNewInstance(4711);
Console.WriteLine("Obj1.getValue(): {0}", obj1.getValue());
Console.WriteLine("Obj2.getValue(): {0}", obj2.getValue());
Console.ReadLine();
}
static void Main(string[] args)
{
String filename = AppDomain.CurrentDomain.SetupInformation.ConfigurationFile;
RemotingConfiguration.Configure(filename);
IRemoteFactory fact = (IRemoteFactory)RemotingHelper.CreateProxy(typeof(IRemoteFactory));
IRemoteObject cao = fact.CreateInstance();
try
{
Console.WriteLine("{0} CLIENT: Calling doSomething()", DateTime.Now);
cao.DoSomething();
}
catch (Exception e)
{
Console.WriteLine(" --> EX: Timeout in first call\n{0}", e.Message);
}
Console.WriteLine("{0} CLIENT: Sleeping for 5 seconds", DateTime.Now);
Thread.Sleep(5000);
try
{
Console.WriteLine("{0} CLIENT: Calling doSomething()", DateTime.Now);
cao.DoSomething();
}
catch (Exception e)
{
Console.WriteLine(" --> EX: Timeout in second call\n{0}", e.Message);
}
Console.WriteLine("Finished ... press <return> to exit");
Console.ReadLine();
Console.ReadLine();
}
private async Task <int> CoherencyUpdatesAsync(
IRemote barOnlyRemote,
IRemoteFactory remoteFactory,
List <DependencyDetail> currentDependencies,
List <DependencyDetail> dependenciesToUpdate)
{
Console.WriteLine("Checking for coherency updates...");
CoherencyMode coherencyMode = CoherencyMode.Strict;
if (_options.LegacyCoherency)
{
coherencyMode = CoherencyMode.Legacy;
}
else
{
Console.WriteLine("Using 'Strict' coherency mode. If this fails, a second attempt utilizing 'Legacy' Coherency mode will be made.");
}
List <DependencyUpdate> coherencyUpdates = null;
bool updateSucceeded = false;
try
{
// Now run a coherency update based on the current set of dependencies updated from the previous pass.
coherencyUpdates = await barOnlyRemote.GetRequiredCoherencyUpdatesAsync(currentDependencies, remoteFactory, coherencyMode);
updateSucceeded = true;
}
catch (DarcCoherencyException e)
{
PrettyPrintCoherencyErrors(e);
}
if (coherencyMode == CoherencyMode.Strict && !updateSucceeded)
{
Console.WriteLine("Attempting fallback to Legacy coherency");
try
{
// Now run a coherency update based on the current set of dependencies updated from the previous pass.
coherencyUpdates = await barOnlyRemote.GetRequiredCoherencyUpdatesAsync(currentDependencies, remoteFactory, CoherencyMode.Legacy);
Console.WriteLine("... Legacy-mode fallback worked");
updateSucceeded = true;
}
catch (DarcCoherencyException e)
{
PrettyPrintCoherencyErrors(e);
}
}
if (!updateSucceeded)
{
return(Constants.ErrorCode);
}
foreach (DependencyUpdate dependencyUpdate in coherencyUpdates)
{
DependencyDetail from = dependencyUpdate.From;
DependencyDetail to = dependencyUpdate.To;
DependencyDetail coherencyParent = currentDependencies.First(d =>
d.Name.Equals(from.CoherentParentDependencyName, StringComparison.OrdinalIgnoreCase));
// Print out what we are going to do.
Console.WriteLine($"Updating '{from.Name}': '{from.Version}' => '{to.Version}' " +
$"to ensure coherency with {from.CoherentParentDependencyName}@{coherencyParent.Version}");
// Final list of dependencies to update
dependenciesToUpdate.Add(to);
}
return(Constants.SuccessCode);
}
/// <summary>
/// Updates existing dependencies in the dependency files
/// </summary>
/// <param name="dependencies">Dependencies that need updates.</param>
/// <param name="remote">Remote instance for gathering eng/common script updates.</param>
/// <returns></returns>
public async Task UpdateDependenciesAsync(List <DependencyDetail> dependencies, IRemoteFactory remoteFactory)
{
// TODO: This should use known updaters, but today the updaters for global.json can only
// add, not actually update. This needs a fix. https://github.com/dotnet/arcade/issues/1095
/*List<DependencyDetail> defaultUpdates = new List<DependencyDetail>(, IRemote remote);
* foreach (DependencyDetail dependency in dependencies)
* {
* if (DependencyOperations.TryGetKnownUpdater(dependency.Name, out Delegate function))
* {
* await (Task)function.DynamicInvoke(_fileManager, _repo, dependency);
* }
* else
* {
* defaultUpdates.Add(dependency);
* }
* }*/
var fileContainer = await _fileManager.UpdateDependencyFiles(dependencies, _repo, null);
List <GitFile> filesToUpdate = fileContainer.GetFilesToCommit();
// TODO: This needs to be moved into some consistent handling between local/remote and add/update:
// https://github.com/dotnet/arcade/issues/1095
// If we are updating the arcade sdk we need to update the eng/common files as well
DependencyDetail arcadeItem = dependencies.FirstOrDefault(
i => string.Equals(i.Name, "Microsoft.DotNet.Arcade.Sdk", StringComparison.OrdinalIgnoreCase));
if (arcadeItem != null)
{
try
{
IRemote remote = await remoteFactory.GetRemoteAsync(arcadeItem.RepoUri, _logger);
List <GitFile> engCommonFiles = await remote.GetCommonScriptFilesAsync(arcadeItem.RepoUri, arcadeItem.Commit);
filesToUpdate.AddRange(engCommonFiles);
List <GitFile> localEngCommonFiles = await _gitClient.GetFilesAtCommitAsync(null, null, "eng/common");
foreach (GitFile file in localEngCommonFiles)
{
if (!engCommonFiles.Where(f => f.FilePath == file.FilePath).Any())
{
file.Operation = GitFileOperation.Delete;
filesToUpdate.Add(file);
}
}
}
catch (Exception exc) when
(exc.Message == "Not Found")
{
_logger.LogWarning("Could not update 'eng/common'. Most likely this is a scenario " +
"where a packages folder was passed and the commit which generated them is not " +
"yet pushed.");
}
}
// Push on local does not commit.
await _gitClient.CommitFilesAsync(filesToUpdate, _repo, null, null);
}
