protected override IEnumerable <IMergeableChangeSet> GetMergeChangeSets(ComponentsFolder targetComponentsFolder)
{
try
{
var result = new List <IMergeableChangeSet>();
var targetGameFolder = GetTargetGameFolder(targetComponentsFolder);
if (targetGameFolder.Math.Exists() && Location.Math.Exists())
{
result.AddRange(Location.Math.GetMergeChangeSets(targetGameFolder.Math));
}
if (targetGameFolder.Limits.Exists() && Location.Math.Exists())
{
result.AddRange(Location.Limits.GetMergeChangeSets(targetGameFolder.Limits));
}
return(result);
}
catch (Exception ex)
{
throw new ApplicationException($"Failed to get Merge Sets for game {this.Name}; SourceBranch = {this.Location}; TargetBranch = {GetTargetGameFolder(targetComponentsFolder)}", ex);
}
}
public GGPSolutionParser(ComponentsFolder componentsFolder, IBuildCustomizationProvider customizationProvider)
{
_componentsFolder = componentsFolder;
_solutionFile = SolutionFile.Parse(GetSolutionFile(componentsFolder));
_customizationProvider = customizationProvider;
LoadComponents();
}
private static IComponentBuilderFactory GetBuildersFactory(ComponentsFolder componentsFolder)
{
IBuildCustomizationProvider buildCustomizationProvider = new VoidCustomizationProvider();
if (componentsFolder.BuildCustomizationXml.Exists())
{
buildCustomizationProvider = new BuildCustomizationProvider(componentsFolder.BuildCustomizationXml.ToSourceControlFile());
}
return(new ComponentBuilderFactory(new GGPSolutionParser(componentsFolder, buildCustomizationProvider)));
}
public IEnumerable <ILogicalComponent> ReadComponents(ComponentsFolder componentsFolder)
{
var installerContent = ReadInstallerContent();
var components = new List <ILogicalComponent>();
foreach (var coreComponent in installerContent.CoreComponents)
{
if (coreComponent.Name == Folders.PackagesFolder.WellKnownName)
{
components.Add(_componentsFactory.CreatePackagesComponent(componentsFolder.Packages,
new MemoryBasedComponentUniqueID(coreComponent.ComponentUniqueId)));
}
else
{
components.Add(_componentsFactory.CreateCoreComponent(componentsFolder.Core.CoreComponent(coreComponent.Name),
new MemoryBasedComponentUniqueID(coreComponent.ComponentUniqueId)));
}
}
foreach (var gameEngine in installerContent.GameEngines)
{
components.Add(_componentsFactory.CreateGameEngineComponent(componentsFolder.EnginesAndGames.GameEngine(gameEngine.Name).Engine,
new MemoryBasedComponentUniqueID(gameEngine.ComponentUniqueId)));
}
var gameLimits = installerContent.GamesLimits.ToDictionary(item => new GameKey(new GameEngineName(item.EngineName), item.Name));
foreach (var gameMath in installerContent.GamesMaths)
{
var gameKey = new GameKey(new GameEngineName(gameMath.EngineName), gameMath.Name);
var mathUniqueId = new MemoryBasedComponentUniqueID(gameMath.ComponentUniqueId);
var limitsUniqueId = new MemoryBasedComponentUniqueID();
if (gameLimits.ContainsKey(gameKey))
{
limitsUniqueId = new MemoryBasedComponentUniqueID(gameLimits[gameKey].ComponentUniqueId);
}
components.Add(_componentsFactory.CreateGameComponent(componentsFolder.EnginesAndGames
.GameEngine(gameMath.EngineName)
.Games
.Game(gameMath.Name),
mathUniqueId,
limitsUniqueId));
}
return(components);
}
public override MergeResult Merge(ComponentsFolder targetComponentsFolder)
{
var targetGameFolder = GetTargetGameFolder(targetComponentsFolder);
var mergeResult = new MergeResult(0);
if (targetGameFolder.Math.Exists() && Location.Math.Exists())
{
mergeResult = mergeResult.Combine(Location.Math.Merge(targetGameFolder.Math));
}
if (targetGameFolder.Limits.Exists() && Location.Math.Exists())
{
mergeResult = mergeResult.Combine(Location.Limits.Merge(targetGameFolder.Limits));
}
return(mergeResult);
}
public override void Branch(ComponentsFolder targetComponentsFolder)
{
var targetGameFolder = GetTargetGameFolder(targetComponentsFolder);
if (targetGameFolder.Math.Exists())
{
throw new InvalidOperationException($"Target branch folder {targetGameFolder.Math.GetServerPath()} already exists!");
}
if (targetGameFolder.Limits.Exists())
{
throw new InvalidOperationException($"Target branch folder {targetGameFolder.Limits.GetServerPath()} already exists!");
}
Location.Math.Branch(targetGameFolder.Math);
if (Location.Limits.Exists())
{
Location.Limits.Branch(targetGameFolder.Limits);
}
}
public virtual Optional <IMergeSet> GetMergeSet(ComponentsFolder targetComponentsFolder)
{
try
{
if (!GetTargetFolder(targetComponentsFolder).Exists())
{
return(Optional <IMergeSet> .Some(new NewComponentMergeSet(this, targetComponentsFolder)));
}
var changeSets = GetMergeChangeSets(targetComponentsFolder);
if (changeSets.Any())
{
return(Optional <IMergeSet> .Some(new ExistingComponentMergeSet(this, changeSets, targetComponentsFolder)));
}
return(Optional <IMergeSet> .None());
}
catch (Exception ex)
{
throw new ApplicationException($"Failed to get Merge Sets for component {this.Name}; SourceBranch = {this.Location}; TargetBranch = {GetTargetFolder(targetComponentsFolder)}", ex);
}
}
private IBuildConfiguration GetBuildConfiguration(ISourceControlAdapter sourceControlAdapter,
ComponentsFolder componentsFolder)
{
var buildOutputFolder = componentsFolder
.Core
.GGPBootstrapper
.ToSourceControlFolder()
.GetLocalPath()
.Subpath("bin")
.Subpath("Release");
var distributionServerPath = sourceControlAdapter.CreateServerPath(_distributionFolderServerPath)
.Subpath(_ggpBranchName.ToString());
var distributionLocalPath = sourceControlAdapter.GetLocalPathFromServerPath(distributionServerPath);
var solutionFile = componentsFolder.GGPGameServerSln.ToSourceControlFile().GetLocalPath();
return(new BuildConfiguration(buildOutputFolder,
distributionLocalPath,
distributionServerPath,
solutionFile));
}
protected override IFolderWithBranchingSupport GetTargetFolder(ComponentsFolder targetComponentsFolder)
{
return(targetComponentsFolder.EnginesAndGames.GameEngine(this.Name).Engine);
}
protected override IFolderWithBranchingSupport GetTargetFolder(ComponentsFolder targetComponentsFolder)
{
return(GetTargetGameFolder(targetComponentsFolder));
}
protected virtual IEnumerable <IMergeableChangeSet> GetMergeChangeSets(ComponentsFolder targetComponentsFolder)
{
return(Location.GetMergeChangeSets(GetTargetFolder(targetComponentsFolder)));
}
public IEnumerable <IComponentBuilder> GetBuilders(IPublishPayload publishPayload, ComponentsFolder componentsFolder)
{
var componentsBuilders = new List <IComponentBuilder>();
var factory = GetBuildersFactory(componentsFolder);
AppendCoreComponentsBuilders(publishPayload, componentsBuilders, factory);
AppendGameEnginesBuilders(publishPayload, componentsBuilders, factory);
return(componentsBuilders);
}
protected override IFolderWithBranchingSupport GetTargetFolder(ComponentsFolder targetComponentsFolder)
{
return(targetComponentsFolder.Packages);
}
private IEnumerable <IComponentBuilder> ReadComponentsBuilders(IPublishPayload publishPayload, ComponentsFolder componentsFolder)
{
_logger.Info("Reading components builders");
return(_services.CreateComponentsBuildersReader().GetBuilders(publishPayload, componentsFolder));
}
protected override IFolderWithBranchingSupport GetTargetFolder(ComponentsFolder targetComponentsFolder)
{
return(targetComponentsFolder.Core.CoreComponent(this.Name));
}
public virtual MergeResult Merge(ComponentsFolder targetComponentsFolder)
{
return(Location.Merge(GetTargetFolder(targetComponentsFolder)));
}
private Folders.GameFolder GetTargetGameFolder(ComponentsFolder targetComponentsFolder)
{
return(targetComponentsFolder.EnginesAndGames.GameEngine(Location.Parent.Parent.Name)
.Games
.Game(this.Name));
}
private static string GetSolutionFile(ComponentsFolder componentsFolder)
{
return(componentsFolder.GGPGameServerSln.ToSourceControlFile().GetLocalPath().AsString());
}
protected override IFolderWithBranchingSupport GetTargetFolder(ComponentsFolder targetComponentsFolder)
{
return(targetComponentsFolder.NonDeployable);
}
