public ServiceFabricServiceProject ReadXml(ServiceFabricServiceProject project, string buildOutputPath)
{
var document = new XmlDocument();
var rawXml = File.ReadAllText(project.SourceServiceManifestPath);
document.LoadXml(rawXml);
var nsManager = new XmlNamespaceManager(document.NameTable);
nsManager.AddNamespace("x", "http://schemas.microsoft.com/2011/01/fabric");
project.ServiceName = document.GetSingleValue("//x:ServiceManifest/@Name", nsManager);
project.ServiceVersion = document.GetSingleValue("//x:ServiceManifest/@Version", nsManager);
var codePackage = GetPackageInfo("CodePackage", PackageType.Code, project, document, nsManager);
codePackage.Path = buildOutputPath;
project.SubPackages.Add(codePackage);
var configPackage = GetPackageInfo("ConfigPackage", PackageType.Config, project, document, nsManager);
project.SubPackages.Add(configPackage);
var dataPackage = GetPackageInfo("DataPackage", PackageType.Data, project, document, nsManager);
if (!string.IsNullOrWhiteSpace(dataPackage.Name))
{
project.SubPackages.Add(dataPackage);
}
return(project);
}
private Dictionary <string, ServiceFabricServiceProject> ExtractProjectReferences(
string basePath,
string buildOutputPathSuffix,
XmlNode document,
XmlNamespaceManager namespaceManager)
{
var projectReferences = new Dictionary <string, ServiceFabricServiceProject>();
var projects = document.SelectNodes("//x:ProjectReference/@Include", namespaceManager);
foreach (var service in projects)
{
if (!(service is XmlAttribute))
{
continue;
}
var attr = service as XmlAttribute;
var projectFile = new FileInfo(Path.Combine(basePath, attr.Value));
var serviceProject = new ServiceFabricServiceProject
{
ProjectFolder = projectFile.Directory,
ProjectFile = projectFile
};
// TODO Ugly Asp.Net hack thing.
ServiceFabricServiceProject projectInfo;
string buildOutputPath;
var projectFileContents = File.ReadAllText(projectFile.FullName, System.Text.Encoding.UTF8);
if (projectFileContents.Contains("<Project Sdk=\"Microsoft.NET.Sdk.Web\">"))
{
var loader = new ManifestLoader <CoreProjectFile>(false);
var projectModel = loader.Load(projectFile.FullName);
var propertyGroup = projectModel.PropertyGroup[0];
buildOutputPath = Path.Combine(serviceProject.ProjectFolder.FullName, "bin", _baseConfig.BuildConfiguration, propertyGroup.TargetFramework, propertyGroup.RuntimeIdentifiers[0]);
projectInfo = _appManifestHandler.ReadXml(serviceProject, buildOutputPath);
projectInfo.IsAspNetCore = true;
}
else
{
buildOutputPath = Path.Combine(serviceProject.ProjectFolder.FullName, buildOutputPathSuffix);
projectInfo = _appManifestHandler.ReadXml(serviceProject, buildOutputPath);
projectInfo.IsAspNetCore = false;
}
projectReferences.Add(projectInfo.ServiceName, projectInfo);
}
return(projectReferences);
}
private static void CopyServiceManifest(ServiceFabricServiceProject service, DirectoryInfo basePackagePath)
{
var servicePackageFolder = service.GetServicePackageFolder(basePackagePath);
if (!servicePackageFolder.Exists)
{
servicePackageFolder.Create();
}
File.Copy(service.SourceServiceManifestPath, service.GetServiceManifestTargetFile(servicePackageFolder).FullName);
}
private static SubPackage GetPackageInfo(
string packageName,
PackageType packageType,
ServiceFabricServiceProject project,
XmlNode document,
XmlNamespaceManager nsManager)
{
var name = document.GetSingleValue($"//x:{packageName}/@Name", nsManager);
var configPackage = new SubPackage
{
Name = name,
Version = document.GetSingleValue($"//x:{packageName}/@Version", nsManager),
PackageType = packageType,
Path = Path.Combine(project.PackageRoot.FullName, name)
};
return(configPackage);
}
private Dictionary <string, ServiceFabricServiceProject> DiscoverAndReadGuestExecutables(ServiceFabricApplicationProject sfProject)
{
var result = new Dictionary <string, ServiceFabricServiceProject>();
var guests = _packageConfig.GuestExecutables.Where(x => x.ApplicationTypeName.Equals(sfProject.ApplicationTypeName, StringComparison.CurrentCultureIgnoreCase));
foreach (var guest in guests)
{
var serviceProject = new ServiceFabricServiceProject
{
IsAspNetCore = false,
ProjectFolder = new DirectoryInfo(Path.Combine(_baseConfig.SourcePath.FullName, guest.PackageName)),
ProjectFile = null,
PackageRoot = new DirectoryInfo(Path.Combine(_baseConfig.SourcePath.FullName, guest.PackageName)),
};
var finalProject = _appManifestHandler.ReadXml(serviceProject, Path.Combine(serviceProject.ProjectFolder.FullName, "Code"));
finalProject.IsGuestExecutable = true;
result.Add(guest.PackageName, finalProject);
}
return(result);
}
private async Task PackageFiles(
ServiceFabricApplicationProject appData,
ServiceFabricServiceProject serviceProject,
KeyValuePair <string, GlobalVersion> service)
{
var appPackagePath = appData.GetPackagePath(_baseConfig.PackageOutputPath);
var servicePackagePath = serviceProject.GetServicePackageFolder(appPackagePath);
DirectoryInfo directory;
IEnumerable <FileInfo> files;
var package = serviceProject.SubPackages
.First(x => x.PackageType == service.Value.PackageType);
var extraFiles = _packageConfig
.ExternalIncludes
.Where(x => x
.ApplicationTypeName.Equals(appData.ApplicationTypeName,
StringComparison.CurrentCultureIgnoreCase))
.Where(x => x
.ServiceManifestName.Equals(serviceProject.ServiceName,
StringComparison.CurrentCultureIgnoreCase))
.Where(x => x
.PackageName.Equals(package.Name,
StringComparison.CurrentCultureIgnoreCase));
if (service.Value.PackageType == PackageType.Code)
{
if (!serviceProject.IsGuestExecutable)
{
directory = new DirectoryInfo(Path.Combine(serviceProject.ProjectFolder.FullName,
appData.BuildOutputPathSuffix));
files = directory
.GetFiles("*", SearchOption.AllDirectories)
.Where(x => _packageConfig.HashIncludeExtensions.Any(include =>
x.FullName.ToLowerInvariant().EndsWith(include.ToLowerInvariant())))
.Select(x => x.FullName)
.OrderBy(x => x)
.Select(x => new FileInfo(x));
}
else
{
directory = new DirectoryInfo(Path.Combine(serviceProject.ProjectFolder.FullName, "Code"));
files = directory
.GetFiles("*", SearchOption.AllDirectories)
.Select(x => x.FullName)
.OrderBy(x => x)
.Select(x => new FileInfo(x));
}
}
else
{
directory = new DirectoryInfo(Path.Combine(serviceProject.PackageRoot.FullName, package.Name));
files = directory
.GetFiles("*", SearchOption.AllDirectories)
.Select(x => x.FullName)
.OrderBy(x => x)
.Select(x => new FileInfo(x));
}
var basePathLength = directory.FullName.Length;
var subPackageFolder = package.GetSubPackageTargetPath(servicePackagePath);
if (!subPackageFolder.Exists)
{
subPackageFolder.Create();
}
foreach (var file in files)
{
var relPath = file.FullName.Remove(0, basePathLength + 1);
var targetFile = new FileInfo(Path.Combine(subPackageFolder.FullName, relPath));
if (!Directory.Exists(targetFile.DirectoryName))
{
Directory.CreateDirectory(targetFile.DirectoryName);
}
File.Copy(file.FullName, targetFile.FullName);
}
foreach (var externalFile in extraFiles)
{
var file = await _fileHandler
.GetFileAsBytesAsync(externalFile.SourceFileName)
.ConfigureAwait(false);
if (!file.IsSuccessful)
{
throw new IOException("Failed to get external file from storage");
}
File.WriteAllBytes(Path.Combine(subPackageFolder.FullName, externalFile.TargetFileName), file.ResponseContent);
}
}
