protected override void OnTargetStart(string target) { if (VersionSuffix.IsNullOrEmpty() && !CustomVersionSuffix.IsNullOrEmpty()) { //module.manifest if (IsModule) { var manifest = ModuleManifest.Clone(); manifest.VersionTag = CustomVersionSuffix; using (var writer = new Utf8StringWriter()) { XmlSerializer xml = new XmlSerializer(typeof(ModuleManifest)); xml.Serialize(writer, manifest); File.WriteAllText(ModuleManifestFile, writer.ToString(), Encoding.UTF8); } } //directory.Build.Props var xmlDoc = new XmlDocument() { PreserveWhitespace = true }; xmlDoc.LoadXml(File.ReadAllText(DirectoryBuildPropsPath)); var suffix = xmlDoc.GetElementsByTagName("VersionSuffix"); suffix[0].InnerText = CustomVersionSuffix; using (var writer = new Utf8StringWriter()) { xmlDoc.Save(writer); File.WriteAllText(DirectoryBuildPropsPath, writer.ToString()); } } base.OnTargetStart(target); }
public void finds_manifest_in_multi_level_tree() { // module name const string moduleName = "moduleName"; // create sub folder const string folderName = "folderName"; string folderPathCreated = Path.Combine(_testDirectory, folderName); Directory.CreateDirectory(folderPathCreated); // create name for manifest string pathToManifest = Path.Combine(folderPathCreated, "SOME_ITCHY_NAME" + ModuleManifest.ManifestFileNameSuffix); // put manifest there var manifest = new ModuleManifest() { ModuleName = moduleName }; var data = XmlSerializerHelper.Serialize(manifest); File.WriteAllBytes(pathToManifest, data); // create package with manifest of the same name var package = GetPackageWithName(moduleName); // run test var folderPathResolved = _moduleFinder.FindDirectoryForPackage(_testDirectory, package); // assert that path to sub folder has been returned Assert.AreEqual(folderPathResolved, folderPathCreated, "The path to folder was not found properly"); }
private void UpdateDependencyIndex(ModuleManifest module) { var dependedModules = Modules.Where(m => m.Manifest.Dependencies.Any(k => k.ModuleName == module.Name)); if (DependencyIndex.Any(m => m.ModuleName == module.Name)) { DependencyIndex.Single(m => m.ModuleName == module.Name).Dep = module.Dependencies.Select(dp => dp.ModuleName).ToList(); //Modules.Single(m => m.Value.Manifest.ModuleName == module.Manifest.ModuleName).Value.Manifest.Dependencies = module.Manifest.Dependencies; try { var oldModule = Modules.Single(m => m.Manifest.Name == module.Name); var dependOnModules = Modules.Where(m => oldModule.Manifest.Dependencies.Select(d => d.ModuleName).Contains(m.Manifest.Name)); var targets = DependencyIndex.Where(dp => dependOnModules.Any(m => m.Manifest.Name == dp.ModuleName)).ToList(); foreach (var target in targets) { DependencyIndex.Single(d => d.ModuleName == target.ModuleName).Cnt--; } } catch { } } else { var temp = new ModuleIndexData { Dep = module.Dependencies.Select(m => m.ModuleName).ToList(), Cnt = 0, ModuleName = module.Name }; DependencyIndex.Add(temp); } foreach (var dependency in module.Dependencies) { DependencyIndex.Single(m => m.ModuleName == dependency.ModuleName).Cnt++; } File.WriteAllText(GetDiFilePath(), JsonConvert.SerializeObject(DependencyIndex)); }
private async Task <string> UploadArtifactAsync(ModuleManifest manifest, string relativeFilePath, string description) { var filePath = Path.Combine(Settings.OutputDirectory, relativeFilePath); // only upload files that don't exist var destinationKey = manifest.ModuleInfo.GetArtifactPath(Path.GetFileName(filePath)); if (_forcePublish || !await DoesS3ObjectExistsAsync(destinationKey)) { Console.WriteLine($"=> Uploading {description}: {Path.GetFileName(destinationKey)}"); var request = new TransferUtilityUploadRequest { FilePath = filePath, BucketName = Settings.DeploymentBucketName, Key = destinationKey }; request.Metadata[AMAZON_METADATA_ORIGIN] = Settings.DeploymentBucketName; try { await _transferUtility.UploadAsync(request); _changesDetected = true; } catch (AmazonS3Exception e) when(e.Message == "The XML you provided was not well-formed or did not validate against our published schema") { // NOTE (2019-09-14, bjorg): this exception can occur on slow/unreliable networks LogError($"unable to upload {description} due to a network error"); } } return(destinationKey); }
private async Task <bool> ImportDependencies(ModuleManifest manifest, bool allowImport = true) { // discover module dependencies var dependencies = await _loader.DiscoverAllDependenciesAsync(manifest, checkExisting : false, allowImport, allowDependencyUpgrades : false); if (HasErrors) { return(false); } // copy all dependencies to deployment bucket that are missing or have a pre-release version foreach (var dependency in dependencies.Where(dependency => dependency.ModuleLocation.SourceBucketName != Settings.DeploymentBucketName)) { var imported = false; // copy check-summed module artifacts (guaranteed immutable) foreach (var artifact in dependency.Manifest.Artifacts) { imported = imported | await ImportS3Object(dependency.ModuleLocation.ModuleInfo.Origin, artifact); } // copy version manifest imported = imported | await ImportS3Object(dependency.ModuleLocation.ModuleInfo.Origin, dependency.ModuleLocation.ModuleInfo.VersionPath, replace : dependency.ModuleLocation.ModuleInfo.Version.IsPreRelease()); // show message if any artifacts were imported if (imported) { Console.WriteLine($"=> Imported {dependency.ModuleLocation.ModuleInfo}"); } } return(true); }
//--- Methods --- public bool TryLoadManifestFromCloudFormationFile(string filepath, out ModuleManifest manifest) { JObject cloudformation; try { // load cloudformation template var template = File.ReadAllText(filepath); cloudformation = JObject.Parse(template); } catch (Exception) { manifest = null; cloudformation = null; return(false); } // extract manifest from cloudformation template if ( cloudformation.TryGetValue("Metadata", out var metadataToken) && (metadataToken is JObject metadata) && metadata.TryGetValue(ModuleManifest.MetadataName, out var manifestToken) ) { manifest = manifestToken.ToObject <ModuleManifest>(); if (manifest.Version == ModuleManifest.CurrentVersion) { return(true); } LogError($"Incompatible LambdaSharp manifest version (found: {manifest.Version ?? "<null>"}, expected: {ModuleManifest.CurrentVersion})"); } else { LogError("CloudFormation file does not contain a LambdaSharp manifest"); } manifest = null; return(false); }
/// <summary> /// Unzips the data from <paramref name="packageData"/> and access <see cref="ModuleManifest"/>. /// </summary> /// <param name="packageData">The raw data of the package.</param> /// <returns><see cref="ModuleInfo"/> object that has ModuleManifest found.</returns> public IModuleInfo UnPack(byte[] packageData) { if (packageData == null) { throw new ArgumentNullException("packageData"); } ZipFile zipFile = null; ModuleManifest manifest = null; try { zipFile = ZipFile.Read(packageData); // find manifest inside the zip data foreach (ZipEntry zipEntry in zipFile) { if (zipEntry.FileName.EndsWith(ModuleManifest.ManifestFileNameSuffix)) { // use this file as manifest var ms = new MemoryStream(); zipEntry.Extract(ms); manifest = XmlSerializerHelper.Deserialize <ModuleManifest>(ms.ToArray()); // now search for the assembly described by this manifest, simply by iterating through zip entries if ( !zipFile.Any( entry => entry.FileName.EndsWith(".dll") | entry.FileName.EndsWith("exe"))) { throw new ArgumentException("No assembly in the package"); } } } } catch (Exception e) { throw new InvalidDataException("The file is corrupted", e); } finally { if (zipFile != null) { zipFile.Dispose(); } } // have not found manifest if (manifest == null) { throw new InvalidDataException("No manifest file in package"); } return(new ModuleInfo { ModuleData = packageData, Manifest = manifest }); }
public static ModuleDescriptor ToModel(this ModuleManifest module) { return(new ModuleDescriptor { Id = module.Id, Title = module.Title, }); }
//--- Constructors --- public ModuleManifestTypeSystem(string source, ModuleManifest manifest) { Source = source ?? throw new ArgumentNullException(nameof(source)); _manifest = manifest; _resourceTypes = new Dictionary <string, IResourceType>(); foreach (var resourceType in manifest.ResourceTypes) { _resourceTypes[resourceType.Type ?? throw new ArgumentException("missing resource type name")] = new ModuleManifestResourceType(resourceType);
private ModuleDescriptor ConvertToModuleDescriptor(ModuleManifest manifest, List <string> installedPackages = null) { ModuleDescriptor result = null; if (manifest != null) { result = new ModuleDescriptor { Id = manifest.Id, Version = manifest.Version, PlatformVersion = manifest.PlatformVersion, Title = manifest.Title, Description = manifest.Description, Authors = manifest.Authors, Owners = manifest.Owners, RequireLicenseAcceptance = manifest.RequireLicenseAcceptance, ReleaseNotes = manifest.ReleaseNotes, Copyright = manifest.Copyright, Tags = manifest.Tags, }; if (manifest.Dependencies != null) { result.Dependencies = manifest.Dependencies.Select(d => new ModuleIdentity { Id = d.Id, Version = d.Version }); } if (manifest.LicenseUrl != null) { result.LicenseUrl = new Uri(manifest.LicenseUrl); } if (manifest.ProjectUrl != null) { result.ProjectUrl = new Uri(manifest.ProjectUrl); } if (manifest.IconUrl != null) { result.IconUrl = new Uri(manifest.IconUrl); } if (installedPackages != null && installedPackages.Any()) { var packageFileName = GetPackageFileName(manifest.Id, manifest.Version); result.IsRemovable = installedPackages.Contains(packageFileName, StringComparer.OrdinalIgnoreCase); } if (_moduleCatalog != null && _moduleCatalog.Modules != null) { result.ModuleInfo = _moduleCatalog.Modules.FirstOrDefault(x => x.ModuleName == result.Id); } } return(result); }
public void ChangeProjectVersion(string prefix = null, string suffix = null) { //theme if (IsTheme) { //var json = JsonDocument.Parse(File.ReadAllText(PackageJsonPath)); //json.RootElement.GetProperty("version") var json = SerializationTasks.JsonDeserializeFromFile <JObject>(PackageJsonPath); json["version"] = prefix; SerializationTasks.JsonSerializeToFile(json, Path.GetFullPath(PackageJsonPath)); } else { //module.manifest if (IsModule) { var manifest = ModuleManifest.Clone(); if (!String.IsNullOrEmpty(prefix)) { manifest.Version = prefix; } if (!String.IsNullOrEmpty(suffix)) { manifest.VersionTag = suffix; } using (var writer = new Utf8StringWriter()) { XmlSerializer xml = new XmlSerializer(typeof(ModuleManifest)); xml.Serialize(writer, manifest); File.WriteAllText(ModuleManifestFile, writer.ToString(), Encoding.UTF8); } } //Directory.Build.props var xmlDoc = new XmlDocument() { PreserveWhitespace = true }; xmlDoc.LoadXml(File.ReadAllText(DirectoryBuildPropsPath)); if (!String.IsNullOrEmpty(prefix)) { var prefixNodex = xmlDoc.GetElementsByTagName("VersionPrefix"); prefixNodex[0].InnerText = prefix; } if (String.IsNullOrEmpty(VersionSuffix) && !String.IsNullOrEmpty(suffix)) { var suffixNodes = xmlDoc.GetElementsByTagName("VersionSuffix"); suffixNodes[0].InnerText = suffix; } using (var writer = new Utf8StringWriter()) { xmlDoc.Save(writer); File.WriteAllText(DirectoryBuildPropsPath, writer.ToString()); } } }
public void publishes_avaliable_modules_message_when_everything_is_ok() { const string assembly = "test_assembly.dll"; var moduleInfo = new ModuleInfo(assembly); var moduleManifest = new ModuleManifest { ModuleName = assembly, ModuleVersion = new Version("0.0.0.0") }; var updateManifest = new ModuleManifest { ModuleName = assembly, ModuleVersion = new Version("0.0.0.1") }; ModuleDiscovery.Setup(x => x.GetModules()).Returns(new List <ModuleInfo> { moduleInfo }); // FIXME: this should use internal manifest factory ModuleManifestFactory.Setup(x => x.GetManifest(It.Is <ModuleInfo>(y => y == moduleInfo))) .Returns(moduleManifest); EventAggregator.Setup(x => x.Publish(It.IsAny <NomadAvailableUpdatesMessage>())) .Callback <NomadAvailableUpdatesMessage>(msg => { Assert.AreEqual(1, msg.AvailableUpdates. Count); Assert.AreEqual(updateManifest, msg.AvailableUpdates. First()); }) .Returns(null) .Verifiable("Message was not published"); ModulesRepository .Setup(x => x.GetAvailableModules()) .Returns(new AvailableModules { Manifests = new List <ModuleManifest> { updateManifest } }) .Verifiable("Get Avaliable modules has not been called"); NomadUpdater.CheckUpdates(); ModulesRepository.Verify(); EventAggregator.Verify(); }
private static string AddManifestFile() { // generate manifest for SimplestModulePossible file var builder = new ManifestBuilder(IssuerName, IssuerXmlPath, @"SimplestModulePossible1.dll", @"Modules\Simple"); _manifest = builder.CreateAndPublish(); return(@"Modules\Simple\SimplestModulePossible1.dll" + ModuleManifest.ManifestFileNameSuffix); }
public async Task <(ModuleManifest Manifest, string Reason)> LoadManifestFromLocationAsync(ModuleLocation moduleLocation) { StartLogPerformance($"LoadManifestFromLocationAsync() for {moduleLocation.ModuleInfo}"); var cached = false; try { // attempt to load manifest from cache var cachedManifestFilePath = GetCachedManifestFilePath(moduleLocation); if (!Settings.ForceRefresh && (cachedManifestFilePath is not null) && File.Exists(cachedManifestFilePath)) { ModuleManifest result = null; try { result = JsonSerializer.Deserialize <ModuleManifest>(await File.ReadAllTextAsync(cachedManifestFilePath), Settings.JsonSerializerOptions); cached = true; return(Manifest : result, Reason : null); } catch { // cached manifest file is either corrupted or inaccessible; attempt to delete it try { File.Delete(cachedManifestFilePath); } catch { // nothing to do } } } // download manifest from S3 var manifestText = await GetS3ObjectContentsAsync(moduleLocation.SourceBucketName, moduleLocation.ModuleInfo.VersionPath); if (manifestText == null) { return(Manifest : null, Reason : $"could not load module manifest for {moduleLocation.ModuleInfo}"); } var manifest = JsonSerializer.Deserialize <ModuleManifest>(manifestText, Settings.JsonSerializerOptions); // validate manifest if (manifest.Version != ModuleManifest.CurrentVersion) { return(Manifest : null, Reason : $"incompatible LambdaSharp manifest version (found: {manifest.Version ?? "<null>"}, expected: {ModuleManifest.CurrentVersion})"); } // keep manifest if we have a valid file path for it if (cachedManifestFilePath is not null) { try { await File.WriteAllTextAsync(cachedManifestFilePath, manifestText); } catch { // cached manifest file could not be written; nothing to do } } return(Manifest : manifest, Reason : null); } finally { StopLogPerformance(cached); } }
public ModuleMeta(Assembly asm, ModuleManifest manifest) { Assembly = asm; ServiceMeta = new ServiceMeta { Name = Assembly.GetName().Name, ModuleName = manifest.Name, VersionMajor = manifest.Version.Major }; TypeChanger = new TypeConverter.TypeConverter(Assembly); ResolveServiceFunctions(); ResolveServiceModels(); }
protected void ResolveRoutes(Assembly assembly, ModuleManifest moduleManifest) { var Types = assembly.GetTypes().Where(m => m.IsSubclassOf(typeof(Controller))); foreach (var type in Types) { var ctrlRouteAttr = type.GetCustomAttribute <RouteAttribute>(); MethodInfo[] methods = GetMethods(type); foreach (var method in methods) { AddMethodToRoute(type, method, moduleManifest.Name, ctrlRouteAttr); } } }
public ModuleInfo LoadModuler(ModuleManifest moduleManifest) { var(_, alc) = HostLoader.LoadPlugin(new PluginInfo { PluginName = moduleManifest.ModuleName, PluginDll = moduleManifest.ModuleEntrypoint }); return(new ModuleInfo { Alc = alc, ModuleAssembly = alc.EntryAssemlby, Manifest = moduleManifest }); }
private async Task <string> UploadTemplateFileAsync(ModuleManifest manifest, string description) { var moduleInfo = manifest.ModuleInfo; // rewrite artifacts in manifest to have an absolute path manifest.Artifacts = manifest.Artifacts .OrderBy(artifact => artifact) .Select(artifact => moduleInfo.GetArtifactPath(artifact)).ToList(); // add template to list of artifacts var destinationKey = manifest.GetModuleTemplatePath(); manifest.Artifacts.Insert(0, destinationKey); // update cloudformation template with manifest and minify it var template = File.ReadAllText(SourceFilename) .Replace(ModuleInfo.MODULE_ORIGIN_PLACEHOLDER, moduleInfo.Origin ?? throw new ApplicationException("missing Origin information")); var cloudformation = JObject.Parse(template); ((JObject)cloudformation["Metadata"])["LambdaSharp::Manifest"] = JObject.FromObject(manifest, new JsonSerializer { NullValueHandling = NullValueHandling.Ignore }); var minified = JsonConvert.SerializeObject(cloudformation, new JsonSerializerSettings { Formatting = Formatting.None, NullValueHandling = NullValueHandling.Ignore }); // upload minified json if (_forcePublish || !await DoesS3ObjectExistsAsync(destinationKey)) { Console.WriteLine($"=> Uploading {description}: {Path.GetFileName(destinationKey)}"); var request = new TransferUtilityUploadRequest { InputStream = new MemoryStream(Encoding.UTF8.GetBytes(minified)), BucketName = Settings.DeploymentBucketName, ContentType = "application/json", Key = destinationKey }; request.Metadata[AMAZON_METADATA_ORIGIN] = Settings.DeploymentBucketName; try { await _transferUtility.UploadAsync(request); _changesDetected = true; } catch (AmazonS3Exception e) when(e.Message == "The XML you provided was not well-formed or did not validate against our published schema") { // NOTE (2019-09-14, bjorg): this exception can occur on slow/unreliable networks LogError("unable to upload template due to a network error"); } } return(destinationKey); }
public void set_up() { _simpleManifest = new ModuleManifest(); _moduleManifestMock = new Mock <IModuleManifestFactory>(MockBehavior.Loose); _moduleManifestMock.Setup(x => x.GetManifest(It.IsAny <ModuleInfo>())).Returns( _simpleManifest); _dependencyMock = new Mock <IDependencyChecker>(MockBehavior.Loose); _dependencyMock.Setup(x => x.SortModules(It.IsAny <IEnumerable <ModuleInfo> >())) .Returns <IEnumerable <ModuleInfo> >(e => e); _moduleFilterMock = new Mock <IModuleFilter>(MockBehavior.Loose); _moduleFilterMock.Setup(x => x.Matches(It.IsAny <ModuleInfo>())).Returns(true); }
private void CreateFilesFromTemplates(string moduleName, Guid?projectGuid) { string modulePath = HostingEnvironment.MapPath("~/Modules/" + moduleName + "/"); string propertiesPath = modulePath + "Properties"; var content = new HashSet <string>(); var folders = new HashSet <string>(); foreach (var folder in _moduleDirectories) { Directory.CreateDirectory(modulePath + folder); if (!String.IsNullOrEmpty(folder)) { folders.Add(modulePath + folder); } } File.WriteAllText(modulePath + "Web.config", File.ReadAllText(_codeGenTemplatePath + "ModuleRootWebConfig.txt")); content.Add(modulePath + "Web.config"); File.WriteAllText(modulePath + "Scripts\\Web.config", File.ReadAllText(_codeGenTemplatePath + "StaticFilesWebConfig.txt")); content.Add(modulePath + "Scripts\\Web.config"); File.WriteAllText(modulePath + "Styles\\Web.config", File.ReadAllText(_codeGenTemplatePath + "StaticFilesWebConfig.txt")); content.Add(modulePath + "Styles\\Web.config"); var assemblyInfoTemplate = new ModuleAssemblyInfo(); assemblyInfoTemplate.Session = new Dictionary <string, object>(); assemblyInfoTemplate.Session["ModuleName"] = moduleName; assemblyInfoTemplate.Session["ModuleTypeLibGuid"] = Guid.NewGuid(); assemblyInfoTemplate.Initialize(); string templateText = assemblyInfoTemplate.TransformText(); File.WriteAllText(propertiesPath + "\\AssemblyInfo.cs", templateText); content.Add(propertiesPath + "\\AssemblyInfo.cs"); var moduleMainfestTemplate = new ModuleManifest(); moduleMainfestTemplate.Session = new Dictionary <string, object>(); moduleMainfestTemplate.Session["ModuleName"] = moduleName; moduleMainfestTemplate.Initialize(); templateText = moduleMainfestTemplate.TransformText(); File.WriteAllText(modulePath + "Module.txt", templateText, System.Text.Encoding.UTF8); content.Add(modulePath + "Module.txt"); var itemGroup = CreateProjectItemGroup(modulePath, content, folders); File.WriteAllText(modulePath + moduleName + ".csproj", CreateCsProject(moduleName, projectGuid, itemGroup)); }
public ModulePackage GetModule(string moduleUniqueName) { IEnumerable <WebModulePackageInfo> packageInfo = _packagesCollection.Where(x => x.Manifest.ModuleName.Equals(moduleUniqueName)); string url = packageInfo.Select(x => x.Url).Single(); ModuleManifest manifest = packageInfo.Select(x => x.Manifest).Single(); byte[] data = _webClient.DownloadData(url); return(new ModulePackage { ModuleManifest = manifest, ModuleZip = data }); }
/// <summary> /// Generates the manifest based on passed parameters and <c>saves manifest to file system</c> /// </summary> /// <remarks> /// Performs the signing of the manifest file. /// </remarks> /// <returns>The newly created manifest.</returns> public ModuleManifest CreateAndPublish() { // perform creation ModuleManifest manifest = Create(); byte[] manifestSerialized = XmlSerializerHelper.Serialize(manifest); // sign the manifest string manifestPath = string.Format("{0}{1}", GetAssemblyPath(), ModuleManifest.ManifestFileNameSuffix); File.WriteAllBytes(manifestPath, manifestSerialized); File.WriteAllBytes(manifestPath + ModuleManifest.ManifestSignatureFileNameSuffix, _signatureAlgorithm.Sign(File.ReadAllBytes(manifestPath))); return(manifest); }
/// <summary> /// Initializes new instance of the <see cref="ModuleInfo"/> class. /// </summary> /// <param name="assemblyPath">Full or relative path to the assembly file containing module's code</param> /// <param name="manifest">Module Manifest connected with assembly file defined in <paramref name="assemblyPath"/>. Can be null.</param> /// <param name="factory">IModuleManifest factory that connects the concrete implementation of ModuleManifest with in program ModuleManifest. Can be null</param> /// <exception cref="ArgumentException"> /// When <paramref name="assemblyPath"/> is <c>null</c> or empty. /// When <paramref name="manifest"/> or <paramref name="factory"/> is <c>null</c>. /// </exception> public ModuleInfo(string assemblyPath, ModuleManifest manifest, IModuleManifestFactory factory) { if (string.IsNullOrEmpty(assemblyPath)) { throw new ArgumentException("assemblyPath is required", assemblyPath); } if (manifest == null && factory == null) { throw new ArgumentException("manifest OR factory is required"); } _assemblyPath = assemblyPath; _manifest = manifest; _moduleManifestFactory = factory; }
public void ChangeProjectVersion(string prefix = null, string suffix = null) { //module.manifest if (IsModule) { var manifest = ModuleManifest.Clone(); if (!String.IsNullOrEmpty(prefix)) { manifest.Version = prefix; } if (!String.IsNullOrEmpty(suffix)) { manifest.VersionTag = suffix; } using (var writer = new Utf8StringWriter()) { XmlSerializer xml = new XmlSerializer(typeof(ModuleManifest)); xml.Serialize(writer, manifest); File.WriteAllText(ModuleManifestFile, writer.ToString(), Encoding.UTF8); } } //directory.Build.Props var xmlDoc = new XmlDocument() { PreserveWhitespace = true }; xmlDoc.LoadXml(File.ReadAllText(DirectoryBuildPropsPath)); if (!String.IsNullOrEmpty(prefix)) { var prefixNodex = xmlDoc.GetElementsByTagName("VersionPrefix"); prefixNodex[0].InnerText = prefix; } if (String.IsNullOrEmpty(VersionSuffix) && !String.IsNullOrEmpty(suffix)) { var suffixNodes = xmlDoc.GetElementsByTagName("VersionSuffix"); suffixNodes[0].InnerText = suffix; } using (var writer = new Utf8StringWriter()) { xmlDoc.Save(writer); File.WriteAllText(DirectoryBuildPropsPath, writer.ToString()); } }
private async Task <string> UploadTemplateFileAsync(ModuleManifest manifest, string description) { var moduleInfo = manifest.ModuleInfo; // rewrite artifacts in manifest to have an absolute path manifest.Artifacts = manifest.Artifacts .OrderBy(artifact => artifact) .Select(artifact => moduleInfo.GetArtifactPath(artifact)).ToList(); // add template to list of artifacts var destinationKey = manifest.GetModuleTemplatePath(); manifest.Artifacts.Insert(0, destinationKey); // update cloudformation template with manifest and minify it var template = File.ReadAllText(SourceFilename) .Replace(ModuleInfo.MODULE_ORIGIN_PLACEHOLDER, moduleInfo.Origin ?? throw new ApplicationException("missing Origin information")); var cloudformation = JObject.Parse(template); ((JObject)cloudformation["Metadata"])["LambdaSharp::Manifest"] = JObject.FromObject(manifest, new JsonSerializer { NullValueHandling = NullValueHandling.Ignore }); var minified = JsonConvert.SerializeObject(cloudformation, new JsonSerializerSettings { Formatting = Formatting.None, NullValueHandling = NullValueHandling.Ignore }); // upload minified json if (_forcePublish || !await DoesS3ObjectExistsAsync(destinationKey)) { Console.WriteLine($"=> Uploading {description}: s3://{Settings.DeploymentBucketName}/{destinationKey}"); var request = new TransferUtilityUploadRequest { InputStream = new MemoryStream(Encoding.UTF8.GetBytes(minified)), BucketName = Settings.DeploymentBucketName, ContentType = "application/json", Key = destinationKey }; request.Metadata[AMAZON_METADATA_ORIGIN] = Settings.DeploymentBucketName; await _transferUtility.UploadAsync(request); _changesDetected = true; } return(destinationKey); }
public void set_up() { _moduleName = "test_module.dll"; var moduleVersion = new Nomad.Utils.Version("0.1.1.0"); _moduleManifest = new ModuleManifest { ModuleName = _moduleName, ModuleVersion = moduleVersion }; // sick creating of dependency checker IEnumerable <ModuleInfo> outter = new List <ModuleInfo>(); DependencyChecker.Setup( x => x.CheckModules(It.IsAny <IEnumerable <ModuleInfo> >(), It.IsAny <IEnumerable <ModuleInfo> >(), out outter)) .Returns(true); }
public IModuleInfo GenerateModuleInfo() { AssemblyName asmName = AssemblyName.GetAssemblyName(AssemblyFilePath); var manifest = new ModuleManifest { ModuleName = asmName.Name, ModuleVersion = new Version(asmName.Version), }; // get the moduleInfo but so called virtual implementation ModuleInfo = new ModuleInfo { Manifest = manifest, ModuleData = File.ReadAllBytes(AssemblyFilePath), }; return(ModuleInfo); }
//--- Methods --- public bool TryLoadFromFile(string filepath, out ModuleManifest manifest) { JObject cloudformation; try { // load cloudformation template var template = File.ReadAllText(filepath); cloudformation = JObject.Parse(template); } catch (Exception) { LogError($"invalid CloudFormation template: {filepath}"); manifest = null; cloudformation = null; return(false); } // extract manifest manifest = GetManifest(cloudformation); return(manifest != null); }
/** * Save state to manifest */ public InventoryManifest CreateManifest() { InventoryManifest manifest = new InventoryManifest(this); foreach (var slot in slots) { if (slot.module == null) { continue; } var slotManifest = new InventorySlotManifest(); ModuleManifest moduleManifest = slot.module.manifest; slotManifest.module = moduleManifest; slotManifest.count = slot.number; moduleManifest.inventorySlotIndex = slots.FindIndex((x) => x == slot); moduleManifest.type = (ModuleType)slot.module.GetType().GetField("type").GetRawConstantValue(); manifest.slots.Add(slotManifest); } return(manifest); }
public void Compare_ModuleManifest_with_added_module_to_old_returns_difference() { var oldModuleManifest = new ModuleManifest(new Module[0]); Module module; var newModuleManifest = new ModuleManifest(new[] { module = new Module( @"scripts/module-a", new Resource[0], new string[0], null ) }); var differences = newModuleManifest.CompareTo(oldModuleManifest); differences.Length.ShouldEqual(1); differences[0].Type.ShouldEqual(ModuleDifferenceType.Added); differences[0].Module.ShouldEqual(module); }
private static void RegisterModuleDependencies(IServiceCollection serviceCollection, bool isConfigureModuleAlone) { var assemblies = DefaultAssemblyPartDiscoveryProvider.DiscoverAssemblyParts(Globals.EntryPointAssembly); var moduleConfiguratorType = typeof(IModuleConfigurator); var moduleConfigurators = assemblies.GetDerivedTypeInfos(moduleConfiguratorType); //new List<TypeInfo>(); var moduleRegistry = InternalServiceProvider.Instance.ServiceProvider.GetService <IModuleRegistry>(); //var registerServiceMethodInfo = moduleConfiguratorType.GetMethod("ConfigureServices"); if (moduleConfigurators.Count <= 0) { return; } foreach (var moduleConfigurator in moduleConfigurators) { var moduleManifest = new ModuleManifest(); moduleManifest.ModuleMetaInfo.ModuleAssemblyFullName = moduleConfigurator.Assembly.FullName; if (Activator.CreateInstance(moduleConfigurator) is IModuleConfigurator moduleConfig) { moduleConfig.ConfigureModule(moduleManifest); moduleManifest.ModuleMetaInfo.AdminConfiguratorTypeInfo = GetAdminConfiguratorInModule(moduleConfigurator.Assembly); moduleRegistry.TryRegisterModule(moduleManifest.ModuleMetaInfo); if (isConfigureModuleAlone) { continue; } moduleConfig.ConfigureServices(serviceCollection); } if (!isConfigureModuleAlone) { //RegisterModuleDbContexts RegisterModuleDbContexts(moduleConfigurator.Assembly, serviceCollection); } } }
XDocument CreateManifestXml(ModuleManifest moduleContainer) { return new XDocument( new XElement("manifest", from module in moduleContainer.Modules select new XElement("module", new XAttribute("path", module.Path), module.Location != null ? new XAttribute("location", module.Location) : null, from resource in module.Resources select new XElement("resource", new XAttribute("path", resource.Path), new XAttribute("hash", resource.Hash.ToHexString()) ), from reference in module.References select new XElement("reference", new XAttribute("path", reference) ) ) ) ); }
public void Compare_ModuleManifest_with_changed_module_to_old_returns_Add_and_Delete_differences() { Module oldModule; var oldModuleManifest = new ModuleManifest(new[] { oldModule = new Module( @"scripts/module-a", new Resource[] { new Resource(@"scripts/module-a/test.js", new byte[] { 1 }, new string[0]) }, new string[0], null ) }); Module changedModule; var newModuleManifest = new ModuleManifest(new[] { changedModule = new Module( @"scripts/module-a", new Resource[] { new Resource(@"scripts/module-a/test.js", new byte[] { 2 }, new string[0]) }, new string[0], null ) }); var differences = newModuleManifest.CompareTo(oldModuleManifest); differences.Length.ShouldEqual(2); differences[0].Type.ShouldEqual(ModuleDifferenceType.Deleted); differences[0].Module.ShouldEqual(oldModule); differences[1].Type.ShouldEqual(ModuleDifferenceType.Added); differences[1].Module.ShouldEqual(changedModule); }
public void Identical_ModuleManifests_have_no_differences() { var oldModuleManifest = new ModuleManifest(new[] { new Module( @"scripts/module-a", new Resource[] { new Resource(@"scripts/module-a/test.js", new byte[0], new string[0]) }, new string[0], null ), new Module(@"scripts/module-b", new Resource[0], new string[0], null) }); var newModuleManifest = new ModuleManifest(new[] { new Module( @"scripts/module-a", new Resource[] { new Resource(@"scripts/module-a/test.js", new byte[0], new string[0]) }, new string[0], null ), new Module(@"scripts/module-b", new Resource[0], new string[0], null) }); var differences = newModuleManifest.CompareTo(oldModuleManifest); differences.Length.ShouldEqual(0); }
public void Write(ModuleManifest manifest) { CreateManifestXml(manifest).Save(stream); }