public async Task SaveVersionAsync(GlobalVersion globalVersionHashMap, VersionNumber version)
{
var payload = JsonConvert.SerializeObject(globalVersionHashMap);
var result = await _blobService
.SaveFileAsync(version.FileName, payload)
.ConfigureAwait(false);
}
public void ItShouldSetVersionOnServiceImport()
{
// g
var appManifest = new ApplicationManifest
{
ServiceManifestImports = new List <ServiceManifestImport>
{
new ServiceManifestImport
{
ServiceManifestRef = new ServiceManifestRef
{
ServiceManifestName = "Service1",
ServiceManifestVersion = "1-hash"
}
},
new ServiceManifestImport
{
ServiceManifestRef = new ServiceManifestRef
{
ServiceManifestName = "Service2",
ServiceManifestVersion = "1-hash"
}
}
},
ApplicationTypeName = "App"
};
var newVersionNumber = VersionNumber.Create(2, "newhash");
var version = new GlobalVersion
{
Hash = "hash",
Version = newVersionNumber
};
var versions = new Dictionary <string, GlobalVersion>
{
["App-Service1"] = new GlobalVersion {
Version = newVersionNumber
}
};
// w
_appManifestHandler.SetGeneralInfo(appManifest, versions, version);
// t
var service1 = appManifest.ServiceManifestImports.Single(
x => x.ServiceManifestRef.ServiceManifestName.Equals("Service1"));
service1.ServiceManifestRef.ServiceManifestVersion.Should().Be("2-newhash");
var service2 = appManifest.ServiceManifestImports.Single(
x => x.ServiceManifestRef.ServiceManifestName.Equals("Service2"));
service2.ServiceManifestRef.ServiceManifestVersion.Should().Be("1-hash");
}
/// <summary>
/// Provide target CFG for passification phase, construct global version map.
/// </summary>
/// <param name="impl">source CFG after passification phase</param>
/// <exception cref="ProofGenUnexpectedStateException">thrown if global version map is incorrect
/// (should never happen). </exception>
public static void AfterPassificationCheckGlobalMap(Implementation impl)
{
afterPassificationImpl = impl;
if (CommandLineOptions.Clo.GenerateIsaProgNoProofs)
{
return;
}
finalProgData = MethodDataFromImpl(impl, boogieGlobalData);
var config = new CFGReprConfigBuilder().SetIsAcyclic(true).SetBlockCopy(true).SetDesugarCalls(false)
.SetDeepCopyPredCmd(TypeCheckBeforeVcMaybeRewritesCmd).Build();
afterPassificationCfg =
CFGReprTransformer.GetCfgRepresentation(impl, config, out afterPassificationToOrigBlock, out _);
var passiveBlocks = new List <Block>(afterPassificationCfg.GetBlocksBackwards());
var origToAfterPassificationBlock = afterPassificationToOrigBlock.InverseDict();
beforePassiveToAfterPassiveBlock =
DictionaryComposition(beforePassiveOrigBlock, origToAfterPassificationBlock);
var globalVersion = new GlobalVersion();
passiveRelationGen = new PassiveRelationGen(
beforePassificationCfg,
passificationHintManager,
initialVarMapping,
beforePassiveOrigBlock,
beforePassiveToAfterPassiveBlock,
ProofGenLiveVarAnalysis.ComputeLiveVariables(beforePassificationCfg, beforePassiveData)
);
//all variables before passification are the initial versions and already constrained
globalVersionMap = globalVersion.GlobalVersionMap(
passiveRelationGen,
beforePassiveData.AllVariables(),
afterPassificationCfg.entry,
passiveBlocks);
//Console.WriteLine("Version map: " + string.Join(Environment.NewLine, globalVersionMap));
var versionMapCorrect =
GlobalVersionChecker.CheckVersionMap(globalVersionMap, passiveRelationGen, beforePassificationCfg,
beforePassiveToAfterPassiveBlock);
if (!versionMapCorrect)
{
throw new ProofGenUnexpectedStateException(typeof(ProofGenerationLayer), "Incorrect version map");
}
}
public void ItShouldSetVersionOnServiceManifest()
{
// g
var oldVersion = VersionNumber.Create(1, "hash");
var newVersion = new GlobalVersion
{
Version = VersionNumber.Create(2, "newhash")
};
var serviceManifest = new ServiceManifest
{
Version = oldVersion.ToString()
};
// w
_serviceManifestHandler.SetServiceManifestGeneral(serviceManifest, newVersion);
// t
serviceManifest.Version.Should().Be("2-newhash");
}
public void SetGeneralInfo(
ApplicationManifest appManifest,
IReadOnlyDictionary <string, GlobalVersion> versions,
GlobalVersion appTypeVersion)
{
appManifest.ApplicationTypeVersion = appTypeVersion.Version.ToString();
foreach (var serviceImport in appManifest.ServiceManifestImports)
{
var serviceName = serviceImport.ServiceManifestRef.ServiceManifestName;
var properServiceKey = $"{appManifest.ApplicationTypeName}-{serviceName}";
if (!versions.ContainsKey(properServiceKey))
{
continue;
}
serviceImport.ServiceManifestRef.ServiceManifestVersion = versions[properServiceKey].Version.ToString();
}
}
public void ItShouldSetAppTypeVersion()
{
// g
var appManifest = new ApplicationManifest
{
ServiceManifestImports = new List <ServiceManifestImport>()
};
var version = new GlobalVersion
{
Hash = "hash",
Version = VersionNumber.Create(2, "hash")
};
var versions = new Dictionary <string, GlobalVersion>();
// w
_appManifestHandler.SetGeneralInfo(appManifest, versions, version);
// t
appManifest.ApplicationTypeVersion.Should().Be("2-hash");
}
public async Task <Dictionary <string, GlobalVersion> > Calculate(
ServiceFabricApplicationProject project,
VersionNumber currentVersion)
{
var projectHashes = new Dictionary <string, GlobalVersion>();
foreach (var service in project.Services)
{
foreach (var subPackage in service.Value.SubPackages)
{
_log.WriteLine($"Computing hash for Service: {service.Key} - Package: {subPackage.Name}");
var hasher = IncrementalHash.CreateHash(HashAlgorithmName.SHA256);
var directory = new DirectoryInfo(subPackage.Path);
IOrderedEnumerable <string> files;
if (subPackage.PackageType == PackageType.Code)
{
if (!service.Value.IsGuestExecutable)
{
files = directory
.GetFiles("*", SearchOption.AllDirectories)
.Where(
x =>
_packageConfig.HashIncludeExtensions.Any(
include =>
x.FullName.EndsWith(include,
StringComparison.CurrentCultureIgnoreCase)))
.Where(
x =>
_packageConfig.HashSpecificExludes.All(
exclude => !x.FullName.ToLowerInvariant()
.Contains(exclude.ToLowerInvariant())))
.Select(x => x.FullName)
.OrderBy(x => x);
}
else
{
files = directory
.GetFiles("*", SearchOption.AllDirectories)
.Where(
x =>
_packageConfig.HashSpecificExludes.All(
exclude => !x.FullName.ToLowerInvariant()
.Contains(exclude.ToLowerInvariant())))
.Select(x => x.FullName)
.OrderBy(x => x);
}
}
else
{
files = directory
.GetFiles("*", SearchOption.AllDirectories)
.Select(x => x.FullName)
.OrderBy(x => x);
}
foreach (var data in files.Select(File.ReadAllBytes))
{
hasher.AppendData(data);
}
var externalIncludes = _packageConfig
.ExternalIncludes
.Where(x => x
.ApplicationTypeName.Equals(project.ApplicationTypeName,
StringComparison.CurrentCultureIgnoreCase))
.Where(x => x
.ServiceManifestName.Equals(service.Value.ServiceName,
StringComparison.CurrentCultureIgnoreCase))
.Where(x => x
.PackageName.Equals(subPackage.Name,
StringComparison.CurrentCultureIgnoreCase))
.OrderBy(x => x.SourceFileName);
foreach (var externalFile in externalIncludes)
{
var file = await _fileHandler
.GetFileAsBytesAsync(externalFile.SourceFileName)
.ConfigureAwait(false);
if (!file.IsSuccessful)
{
throw new IOException("Failed to get external file from storage");
}
hasher.AppendData(file.ResponseContent);
}
var finalHash = hasher.GetHashAndReset();
var hash = BitConverter.ToString(finalHash).Replace("-", "").ToLowerInvariant();
var packageVersion = new GlobalVersion
{
Hash = hash,
VersionType = VersionType.ServicePackage,
ParentRef = $"{project.ApplicationTypeName}-{service.Key}",
PackageType = subPackage.PackageType
};
projectHashes.Add($"{project.ApplicationTypeName}-{service.Key}-{subPackage.Name}", packageVersion);
}
var serviceManifest = _serviceManifestLoader.Load(service.Value.SourceServiceManifestPath);
_manifestHandler.SetServiceEndpoints(serviceManifest, project.ApplicationTypeName, service.Value.ServiceName);
using (var serviceManifestStream = new MemoryStream())
{
_serviceManifestLoader.Save(serviceManifest, serviceManifestStream);
var serviceVersion = new GlobalVersion
{
VersionType = VersionType.Service,
ParentRef = project.ApplicationTypeName,
Hash = HashStream(serviceManifestStream)
};
projectHashes.Add($"{project.ApplicationTypeName}-{service.Key}", serviceVersion);
}
}
var appManifest = _appManifestLoader.Load(project.ApplicationManifestFileFullPath);
_manifestHandler.CleanAppManifest(appManifest);
_handleEndpointCert.SetEndpointCerts(_packageConfig, appManifest, project.ApplicationTypeName);
_handleEnciphermentCert.SetEnciphermentCerts(_packageConfig, appManifest, project.ApplicationTypeName);
var guests = _packageConfig.GuestExecutables.Where(x =>
x.ApplicationTypeName.Equals(project.ApplicationTypeName, StringComparison.CurrentCultureIgnoreCase));
foreach (var guest in guests)
{
var policies = new Policies();
if (guest.GuestRunAs != null)
{
var runAs = new RunAsPolicy
{
UserRef = guest.GuestRunAs.UserName,
CodePackageRef = "Code"
};
var runAsPolicies = new List <RunAsPolicy> {
runAs
};
policies.RunAsPolicy = runAsPolicies;
if (appManifest.Principals == null)
{
appManifest.Principals = new Principals();
}
if (appManifest.Principals.Users == null)
{
appManifest.Principals.Users = new Users();
}
if (appManifest.Principals.Users.User == null)
{
appManifest.Principals.Users.User = new List <User>();
}
if (!appManifest.Principals.Users.User.Any(x =>
x.Name.Equals(guest.GuestRunAs.UserName, StringComparison.CurrentCultureIgnoreCase)))
{
var user = new User
{
Name = guest.GuestRunAs.UserName,
AccountType = guest.GuestRunAs.AccountType
};
appManifest.Principals.Users.User.Add(user);
}
}
var serviceManifestRef = new ServiceManifestRef
{
ServiceManifestName = guest.PackageName,
ServiceManifestVersion = "1.0.0"
};
var serviceImport = new ServiceManifestImport
{
ServiceManifestRef = serviceManifestRef,
ConfigOverrides = new ConfigOverrides(),
Policies = policies
};
appManifest.ServiceManifestImports.Add(serviceImport);
}
using (var appManifestStream = new MemoryStream())
{
_appManifestLoader.Save(appManifest, appManifestStream);
projectHashes.Add(project.ApplicationTypeName, new GlobalVersion
{
VersionType = VersionType.Application,
Version = currentVersion,
Hash = HashStream(appManifestStream)
});
}
return(projectHashes);
}
public void SetServiceManifestGeneral(
ServiceManifest serviceManifest,
GlobalVersion version)
{
serviceManifest.Version = version.Version.ToString();
}
