public IEnumerable <IMergeSet> ReadMergeSets(IEnumerable <ILogicalComponent> components,
Folders.ComponentsFolder targetComponentsFolder)
{
var workers = new List <Worker>();
foreach (var component in components)
{
component.As <ISupportBranching>()
.Do(sb => workers.Add(new Worker(sb, targetComponentsFolder, _threadingServices, this.Logger)));
}
var tasks = new List <Task>();
foreach (var worker in workers)
{
tasks.Add(worker.Start());
}
Task.WaitAll(tasks.ToArray());
if (workers.Any(w => w.Exception != null))
{
throw new ApplicationException("Reading MergeSets failed! See the logs for more details!");
}
return(workers.SelectMany(w => w.MergeSet).ToList());
}
private IEnumerable <BuildAction> GetBranchCoreComponentsActions(Folders.ComponentsFolder installerComponentsFolder, DeveloperToolService.GetInstallerContentResponse installerContent)
{
var actions = new List <BuildAction>();
foreach (var coreComponent in installerContent.CoreComponents)
{
if (coreComponent.Name == Folders.PackagesFolder.WellKnownName)
{
actions.Add(new BuildAction($"Branch {coreComponent.Name}",
() =>
{
var targetPath = installerComponentsFolder.Packages.GetServerPath();
BranchComponent(coreComponent.ProjectFolder, targetPath, coreComponent.ChangeSet);
}));
}
else
{
actions.Add(new BuildAction($"Branch core component {coreComponent.Name}",
() =>
{
var targetPath = installerComponentsFolder.Core.CoreComponent(coreComponent.Name).GetServerPath();
BranchComponent(coreComponent.ProjectFolder, targetPath, coreComponent.ChangeSet);
}));
}
}
return(actions);
}
private void BranchComponents()
{
Folders.ComponentsFolder targetComponentsFolder = _targetBranchFolder.Components.Create();
for (int i = 0; i < _sourceComponents.Count; i++)
{
var component = _sourceComponents[i];
try
{
_progressCallback?.Invoke(ProgressCallbackData.Create(i,
_sourceComponents.Count,
"Branching " + component.Name));
component.As <ISupportBranching>().Do(c => c.Branch(targetComponentsFolder));
_progressCallback?.Invoke(ProgressCallbackData.Create(i + 1,
_sourceComponents.Count,
"Branching " + component.Name));
}
catch (Exception ex)
{
throw new ApplicationException($"Failed to branch component {component.Name}!{Environment.NewLine}Error details: {ex.Message}", ex);
}
}
}
public ExistingComponentMergeSet(ILogicalComponent sourceComponent,
IEnumerable <IMergeableChangeSet> changeSets,
Folders.ComponentsFolder targetComponentsFolder)
{
this.SourceComponent = sourceComponent;
this.ChangeSets = changeSets;
_targetComponentsFolder = targetComponentsFolder;
}
public IEnumerable <ILogicalComponent> ReadComponents(Folders.ComponentsFolder componentsFolder)
{
var components = new List <ILogicalComponent>();
components.AddRange(GetCoreComponents(componentsFolder));
components.AddRange(GetGameEngines(componentsFolder));
return(components);
}
public Worker(ISupportBranching branchableComponent,
Folders.ComponentsFolder targetComponentsFolder,
IThreadingServices threadingServices,
ILogger logger)
{
_branchableComponent = branchableComponent;
_targetComponentsFolder = targetComponentsFolder;
_threadingServices = threadingServices;
_logger = logger;
}
public virtual void Branch(Folders.ComponentsFolder targetComponentsFolder)
{
var targetFolder = GetTargetFolder(targetComponentsFolder);
if (targetFolder.Exists())
{
throw new InvalidOperationException($"Target branch folder {targetFolder.Name} already exists!");
}
Location.Branch(targetFolder);
}
private IEnumerable <ILogicalComponent> GetGameEngines(Folders.ComponentsFolder componentsFolder)
{
var enginesAndGames = new List <ILogicalComponent>();
foreach (var gameEngineFolder in componentsFolder.EnginesAndGames.AllGameEngines)
{
enginesAndGames.Add(_componentsFactory.CreateGameEngineComponent(gameEngineFolder.Engine));
enginesAndGames.AddRange(ReadGames(gameEngineFolder));
}
return(enginesAndGames);
}
private IEnumerable <ILogicalComponent> GetCoreComponents(Folders.ComponentsFolder componentsFolder)
{
var result = componentsFolder.Core.AllCoreComponents
.Select(folder => _componentsFactory.CreateCoreComponent(folder))
.ToList();
if (componentsFolder.Packages.Exists())
{
result.Add(_componentsFactory.CreatePackagesComponent(componentsFolder.Packages));
}
if (componentsFolder.NonDeployable.Exists())
{
result.Add(_componentsFactory.CreateNonDeployableComponent(componentsFolder.NonDeployable));
}
return(result);
}
private IEnumerable <BuildAction> GetBranchEnginesAndGamesActions(Folders.ComponentsFolder installerComponentsFolder, DeveloperToolService.GetInstallerContentResponse installerContent)
{
var actions = new List <BuildAction>();
foreach (var gameEngine in installerContent.GameEngines)
{
actions.Add(new BuildAction($"Branching game engine {gameEngine.Name}",
() =>
{
var targetPath = installerComponentsFolder.EnginesAndGames.GameEngine(gameEngine.Name).Engine.GetServerPath();
BranchComponent(gameEngine.ProjectFolder, targetPath, gameEngine.ChangeSet);
}));
}
foreach (var gameMath in installerContent.GamesMaths)
{
actions.Add(new BuildAction($"Branching math for game {gameMath.Name} in engine {gameMath.EngineName}",
() =>
{
var targetPath = installerComponentsFolder.EnginesAndGames.GameEngine(gameMath.EngineName)
.Games
.Game(gameMath.Name)
.Math
.GetServerPath();
BranchComponent(gameMath.ProjectFolder, targetPath, gameMath.ChangeSet);
}));
}
foreach (var gameLimits in installerContent.GamesLimits)
{
actions.Add(new BuildAction($"Branching limits for game {gameLimits.Name} in engine {gameLimits.EngineName}",
() =>
{
var targetPath = installerComponentsFolder.EnginesAndGames.GameEngine(gameLimits.EngineName)
.Games
.Game(gameLimits.Name)
.Limits
.GetServerPath();
BranchComponent(gameLimits.ProjectFolder, targetPath, gameLimits.ChangeSet);
}));
}
return(actions);
}
private void Build(IFolderHolder qaMainFolder, Folders.ComponentsFolder componentsFolder, IFileHolder latestPublishXml, PublishPayloadHolder publishPayloadInfo,
Optional <GGPDeploymentContent.InstallerCustomizationInfo> customizedInstaller)
{
var sourceControlAdapter = _services.CreateSourceControlAdapter();
_logger.Info($"Execute Get Latest for {qaMainFolder.GetServerPath().AsString()}");
sourceControlAdapter.GetLatest(qaMainFolder);
var buildContext = new BuildContext(_services,
GetBuildConfiguration(sourceControlAdapter, componentsFolder),
new DeploymentContentBuilder(publishPayloadInfo.PublisherEmailAddress, _ggpBranchName, _buildType,
customizedInstaller),
sourceControlAdapter);
var components = ReadComponentsBuilders(publishPayloadInfo.PublishPayload, componentsFolder);
var actions = GetBuildActionsList(components, publishPayloadInfo.PublishFileContent, latestPublishXml);
foreach (var a in actions)
{
a.Execute(buildContext);
}
}
protected abstract IFolderWithBranchingSupport GetTargetFolder(Folders.ComponentsFolder targetComponentsFolder);
public NewComponentMergeSet(ILogicalComponent sourceComponent, Folders.ComponentsFolder targetComponentsFolder)
{
this.SourceComponent = sourceComponent;
_targetComponentsFolder = targetComponentsFolder;
}
