public void load_packages_by_assembly() { var includes = new PackageManifest(); new FileSystem().PersistToFile(includes, theApplicationDirectory, PackageManifest.FILE); var links = new LinkManifest(); links.AddLink("../TestPackage1"); new FileSystem().PersistToFile(links, theApplicationDirectory, LinkManifest.FILE); var assemblyLoader = new AssemblyLoader(new PackagingDiagnostics()); assemblyLoader.AssemblyFileLoader = file => Assembly.Load(Path.GetFileNameWithoutExtension(file)); var package = linkedFolderReader.Load(new PackageLog()).Single(); assemblyLoader.LoadAssembliesFromPackage(package); assemblyLoader .Assemblies .Single() .GetName() .Name .ShouldEqual("TestPackage1"); }
private void BtnCreate_Click(object sender, RoutedEventArgs e) { if (ValidateManifest()) { Manifest = new PackageManifest(); Manifest.PackageName = tbName.Text; Manifest.Author = tbAuthor.Text; Manifest.Version = tbVersion.Text; Manifest.DllPath = cbbMainDll.SelectedValue.ToString(); Manifest.Description = tbDescription.Text; PackageDefinition definition = Definitions.Find(def => def.Extension == cbbPackageType.SelectedValue.ToString()); SaveFileDialog saveFileDialog = new SaveFileDialog(); saveFileDialog.Filter = $"{definition.Name} (*.{definition.Extension})"; bool?result = saveFileDialog.ShowDialog(); if (result.HasValue) { if (result.Value == true) { if (Packages.Pack(contents.ToList(), saveFileDialog.FileName, Manifest)) { DoneAlert.Show($"package created.\nLocation:\n{saveFileDialog.FileName}"); } } } } }
public void CanParseManifest_TrackingAllowed() { const string json = @"{""allowPackageTelemetry"": false }"; PackageManifest manifest = _parser.ParseManifest(json); Assert.IsFalse(manifest.AllowPackageTelemetry); }
public void DelimitedValueValidator() { const string json = @"{'propertyEditors': [ { alias: 'Test.Test2', name: 'Test 2', isParameterEditor: true, defaultConfig: { key1: 'some default val' }, editor: { view: '~/App_Plugins/MyPackage/PropertyEditors/MyEditor.html', valueType: 'int', validation: { delimited: { delimiter: ',', pattern: '^[a-zA-Z]*$' } } } } ]}"; PackageManifest manifest = _parser.ParseManifest(json); Assert.AreEqual(1, manifest.ParameterEditors.Length); Assert.AreEqual(1, manifest.ParameterEditors[0].GetValueEditor().Validators.Count); Assert.IsTrue(manifest.ParameterEditors[0].GetValueEditor().Validators[0] is DelimitedValueValidator); var validator = manifest.ParameterEditors[0].GetValueEditor().Validators[0] as DelimitedValueValidator; Assert.IsNotNull(validator.Configuration); Assert.AreEqual(",", validator.Configuration.Delimiter); Assert.AreEqual("^[a-zA-Z]*$", validator.Configuration.Pattern); }
public void read_a_package_manifest() { var manifest = new PackageManifest { Role = "application", Name = "something" }; new FileSystem().WriteObjectToFile(PackageManifest.FILE, manifest); if (File.Exists("zip1.zip")) { File.Delete("zip1.zip"); } using (var zip1 = new ZipFile("zip1.zip")) { zip1.AddFile(PackageManifest.FILE, ""); zip1.Save(); } var service = new ZipFileService(new FileSystem()); var manifest2 = service.GetPackageManifest("zip1.zip"); manifest2.Name.ShouldEqual(manifest.Name); manifest2.Role.ShouldEqual(manifest.Role); }
public void read_a_package_manifest() { theOriginal = new ApplicationManifest { Name = "Han Solo", ContentFileSet = new FileSet() { DeepSearch = true, Exclude = "*.xml", Include = "*.config" }, DataFileSet = new FileSet() { DeepSearch = true, Exclude = "*.txt", Include = "*.xml" } }; theOriginal.AddAssembly("Fubu.Assem1"); theOriginal.AddAssembly("Fubu.Assem2"); theOriginal.AddAssembly("Fubu.Assem3"); new FileSystem().WriteObjectToFile("manifest.xml", theOriginal); var reader = new PackageManifestXmlReader(); theResultingManifest = reader.ReadFrom("manifest.xml"); }
public HttpResponseMessage Generate(PackageManifest manifest) { try { var filePath = Services.PackageBuilder.GeneratePackage(manifest); var result = new HttpResponseMessage(HttpStatusCode.OK) { Content = new ByteArrayContent(File.ReadAllBytes(filePath)) }; result.Content.Headers.ContentDisposition = new ContentDispositionHeaderValue("attachment") { FileName = $"{manifest.PackageName}.zip" }; result.Content.Headers.ContentType = new MediaTypeHeaderValue("application/octet-stream"); return(result); } catch (Exception exception) { var httpResponseMessage = new HttpResponseMessage(HttpStatusCode.InternalServerError); httpResponseMessage.Content = new StringContent( JsonConvert.SerializeObject(exception.Message), System.Text.Encoding.UTF8, "application/json"); return(httpResponseMessage); } }
public void set_role_to_binaries() { var manifest = new PackageManifest(); manifest.SetRole(BottleRoles.Binaries); manifest.ContentFileSet.ShouldBeNull(); }
public void set_role_to_data() { var manifest = new PackageManifest(); manifest.SetRole(BottleRoles.Data); manifest.ContentFileSet.ShouldBeNull(); }
private void UpdatePackageManifest(Package package, PackagePart updatedPart) { if (package == null) throw new ArgumentNullException(nameof(package)); if (updatedPart == null) throw new ArgumentNullException(nameof(updatedPart)); if (package.FileOpenAccess != FileAccess.ReadWrite) throw new InvalidOperationException("Package must be open for reading and writing"); var manifestRelation = package.GetRelationship("MANIFEST"); var manifestPart = package.GetPart(manifestRelation.TargetUri); // parse manifest var manifest = new PackageManifest(manifestPart, null); // rehash updated part var csDefPart = manifest.Items.FirstOrDefault(i => i.PartUri == updatedPart.Uri); if (csDefPart == null) throw new InvalidOperationException(string.Format("Unable to find part '{0}' in package manifest", updatedPart.Uri)); csDefPart.Hash = manifest.HashAlgorithm.ComputeHash(updatedPart.GetStream(FileMode.Open, FileAccess.Read)); ; csDefPart.ModifiedDate = DateTime.UtcNow; var manifestStream = manifestPart.GetStream(FileMode.Open, FileAccess.Write); manifest.WriteToStream(manifestStream); }
private void writeZipFile(CreatePackageInput input, PackageManifest manifest, AssemblyFiles assemblies) { var zipFileName = input.GetZipFileName(manifest); if (_fileSystem.FileExists(zipFileName)) { LogWriter.Current.Highlight(" Deleting existing file at " + zipFileName); _fileSystem.DeleteFile(zipFileName); } _zipFileService.CreateZipFile(zipFileName, zipFile => { assemblies.Files.Each(file => { zipFile.AddFile(file, "bin"); }); if (input.PdbFlag) { assemblies.PdbFiles.Each(file => { zipFile.AddFile(file, "bin"); }); } WriteVersion(zipFile); zipFile.AddFile(FileSystem.Combine(input.PackageFolder, PackageManifest.FILE), ""); // TODO -- there's an opportunity to generalize this AddDataFiles(input, zipFile, manifest); AddContentFiles(input, zipFile, manifest); AddConfigFiles(input, zipFile, manifest); }); }
private void writeZipFile(CreatePackageInput input, PackageManifest manifest, AssemblyFiles assemblies) { _zipFileService.CreateZipFile(input.GetZipFileName(manifest), zipFile => { assemblies.Files.Each(file => { zipFile.AddFile(file, "bin"); }); if (input.PdbFlag) { assemblies.PdbFiles.Each(file => { zipFile.AddFile(file, "bin"); }); } WriteVersion(zipFile); zipFile.AddFile(FileSystem.Combine(input.PackageFolder, PackageManifest.FILE), ""); // TODO -- there's an opportunity to generalize this AddDataFiles(input, zipFile, manifest); AddContentFiles(input, zipFile, manifest); AddConfigFiles(input, zipFile, manifest); }); }
private void writeZipFile(CreateBottleInput input, PackageManifest manifest, AssemblyFiles assemblies) { var zipFileName = input.GetZipFileName(manifest); if (_fileSystem.FileExists(zipFileName)) { LogWriter.Current.Highlight(" Deleting existing file at " + zipFileName); _fileSystem.DeleteFile(zipFileName); } _zipFileService.CreateZipFile(zipFileName, zipFile => { assemblies.Files.Each(file => { zipFile.AddFile(file, "bin"); }); if (input.PdbFlag) { assemblies.PdbFiles.Each(file => { zipFile.AddFile(file, "bin"); }); } WriteVersion(zipFile); zipFile.AddFile(FileSystem.Combine(input.PackageFolder, PackageManifest.FILE), ""); // TODO -- there's an opportunity to generalize this AddDataFiles(input, zipFile, manifest); AddContentFiles(input, zipFile, manifest); AddConfigFiles(input, zipFile, manifest); }); }
public void SetManifest(PackageManifest thisManifest) { if (thisManifest == null) { throw new ArgumentNullException(nameof(thisManifest)); } _children.Clear(); foreach (PackageDependency pd in thisManifest.Dependencies) { _children.Add(new DependencyNode(this, pd.PackageId, pd.Framework, new VersionRangeExtended(pd.AllowedVersions) { ReleaseLabel = AllowedVersions.ReleaseLabel })); } HasManifest = true; // TODO: Hack to populate the Framework to Pundit packages which come from a dependency of a NuGet as NuGet does not have a FW defined in the Manifest if (Framework == null && thisManifest.LegacyFramework != null) { Framework = thisManifest.LegacyFramework; } }
protected override void beforeEach() { theBaseFolder = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "folder1"); theBinFolder = Path.Combine(theBaseFolder, "bin"); theManifest = new PackageManifest { Assemblies = "A;B;C", DataFileSet = new FileSet(), ContentFileSet = new FileSet() }; theInput = new CreatePackageInput() { PackageFolder = theBaseFolder }; theAssemblyFiles = new AssemblyFiles() { Files = new string[] { "a.dll", "b.dll" }, MissingAssemblies = new string[] { "c" }, PdbFiles = new string[] { "a.dll", "b.dll", "c.dll" }, Success = false }; MockFor <IAssemblyFileFinder>() .Stub(x => x.FindAssemblies(theBinFolder, theManifest.AssemblyNames)) .Return(theAssemblyFiles); ClassUnderTest.CreatePackage(theInput, theManifest); }
public void print_sample_manifest() { var manifest = new PackageManifest { Id = "linqpad", Version = "4.51.03", Home = "http://www.linqpad.net/", InstallMethod = InstallMethodTypes.Zip, Installers = new List <Installer> { new Installer { Location = "http://www.linqpad.net/GetFile.aspx?LINQPad4-AnyCPU.zip", Architecture = ArchitectureTypes.x86 }, new Installer { Location = "http://www.linqpad.net/GetFile.aspx?LINQPad4-AnyCPU.zip", Architecture = ArchitectureTypes.x86, MinWindowsVersion = WindowsVersion.KnownVersions.First(), } } }; Console.WriteLine(manifest.ToYaml()); }
public IEnumerable<BottleExplosionRequest> DetermineExplosionRequests(PackageManifest manifest) { switch (manifest.Role) { case BottleRoles.Module: yield return new BottleExplosionRequest { BottleDirectory = SchedTaskPackageFacility.PackagesFolder, BottleName = manifest.Name, DestinationDirectory = _physicalPath.AppendPath(BottleFiles.PackagesFolder) //is this correct }; break; case BottleRoles.Config: yield return new BottleExplosionRequest { BottleDirectory = BottleFiles.ConfigFolder, BottleName = manifest.Name, DestinationDirectory = _physicalPath.AppendPath(BottleFiles.ConfigFolder) }; break; case BottleRoles.Binaries: case BottleRoles.Application: yield return new BottleExplosionRequest { BottleDirectory = BottleFiles.BinaryFolder, BottleName = manifest.Name, DestinationDirectory = _physicalPath }; break; default: yield break; } }
void InstallManifest(PackageManifest packageManifest) { if (Directory.Exists(packageManifestPath) == false) { Directory.CreateDirectory(packageManifestPath); } string manifestFilePath = Path.Combine(packageManifestPath, packageManifest.title) + ".manifest"; if (Provider.isActive) { Asset manifestAsset = new Asset(manifestFilePath); Task statusTask = Provider.Status(manifestAsset); statusTask.Wait(); AssetList manifestAssetList = statusTask.assetList; manifestAsset = manifestAssetList[0]; if (File.Exists(manifestFilePath) == true) { if (Provider.IsOpenForEdit(manifestAssetList[0]) == false) { Task checkoutTask = Provider.Checkout(manifestAssetList, CheckoutMode.Asset); checkoutTask.Wait(); if (checkoutTask.success == false) { throw new Exception(string.Format("Failed to check out manifest file {0}", manifestFilePath)); } } } } //If there's an existing manifest at this point, merge in the installed files from previous runs. //Since you can install a package multiple times with different subsets of the files, we need to aggregate the results of the separate //installations if (File.Exists(manifestFilePath) == true) { PackageManifest oldManifest = (PackageManifest)JsonUtility.FromJson(File.ReadAllText(manifestFilePath), typeof(PackageManifest)); packageManifest.filelistInstalled.AddRange(oldManifest.filelistInstalled.Except(packageManifest.filelistInstalled, new PackageManifestEntryComparer())); } File.WriteAllText(manifestFilePath, JsonUtility.ToJson(packageManifest)); if (Provider.isActive) { Asset manifestAsset = new Asset(manifestFilePath); Task statusTask = Provider.Status(manifestAsset); statusTask.Wait(); AssetList manifestAssetList = statusTask.assetList; manifestAsset = manifestAssetList[0]; if (manifestAsset.isInCurrentProject == false) { Task addTask = Provider.Add(manifestAssetList, false); addTask.Wait(); if (addTask.success == false) { throw new Exception(string.Format("Failed to add manifest file {0} to version control", manifestFilePath)); } } } }
public void CanParseManifest_GridEditors() { const string json = @"{ 'javascript': [ ], 'css': [ ], 'gridEditors': [ { 'name': 'Small Hero', 'alias': 'small-hero', 'view': '~/App_Plugins/MyPlugin/small-hero/editortemplate.html', 'render': '~/Views/Partials/Grid/Editors/SmallHero.cshtml', 'icon': 'icon-presentation', 'config': { 'image': { 'size': { 'width': 1200, 'height': 185 } }, 'link': { 'maxNumberOfItems': 1, 'minNumberOfItems': 0 } } }, { 'name': 'Document Links By Category', 'alias': 'document-links-by-category', 'view': '~/App_Plugins/MyPlugin/document-links-by-category/editortemplate.html', 'render': '~/Views/Partials/Grid/Editors/DocumentLinksByCategory.cshtml', 'icon': 'icon-umb-members' } ] }"; PackageManifest manifest = _parser.ParseManifest(json); Assert.AreEqual(2, manifest.GridEditors.Length); GridEditor editor = manifest.GridEditors[0]; Assert.AreEqual("small-hero", editor.Alias); Assert.AreEqual("Small Hero", editor.Name); Assert.AreEqual(_ioHelper.ResolveUrl("/App_Plugins/MyPlugin/small-hero/editortemplate.html"), editor.View); Assert.AreEqual(_ioHelper.ResolveUrl("/Views/Partials/Grid/Editors/SmallHero.cshtml"), editor.Render); Assert.AreEqual("icon-presentation", editor.Icon); IDictionary <string, object> config = editor.Config; Assert.AreEqual(2, config.Count); Assert.IsTrue(config.ContainsKey("image")); object c = config["image"]; Assert.IsInstanceOf <JObject>(c); // FIXME: is this what we want? Assert.IsTrue(config.ContainsKey("link")); c = config["link"]; Assert.IsInstanceOf <JObject>(c); // FIXME: is this what we want? // FIXME: should we resolveUrl in configs? }
public InstallerException(int exitCode, PackageManifest packageManifest, ExistReason exitReason, string logPath) : base(GetMessage(exitCode, packageManifest, exitReason, logPath)) { PackageManifest = packageManifest; LogPath = logPath; ExitReason = exitReason; ExitCode = exitCode; }
private void persist(IFileSystem fileSystem, ManifestInput input, PackageManifest manifest) { Console.WriteLine(""); Console.WriteLine("Persisted changes to " + FileSystem.Combine(input.AppFolder, PackageManifest.FILE)); Console.WriteLine(""); fileSystem.PersistToFile(manifest, input.AppFolder, PackageManifest.FILE); }
public void WriteAssembliesNotFound(AssemblyFiles theAssemblyFiles, PackageManifest manifest, CreatePackageInput input) { Console.WriteLine("Did not locate all designated assemblies at {0}", input.PackageFolder); Console.WriteLine("Looking for these assemblies in the package manifest file:"); manifest.AssemblyNames.Each(name => Console.WriteLine(" " + name)); Console.WriteLine("But only found"); theAssemblyFiles.Files.Each(file => Console.WriteLine(" " + file)); }
private static PackageManifest createDefaultManifest(string packageDirectory) { var manifest = PackageManifest.DefaultModuleManifest(); manifest.AddAssembly(LinkCommand.GuessAssemblyNameForFolder(packageDirectory, new FileSystem())); manifest.Name = Path.GetFileName(packageDirectory); return(manifest); }
public InstallerContext Build(PackageManifest manifest, InstallInteractivityLevel interactivityLevel, PackageOperation operation) { return(new InstallerContext(manifest.Id, interactivityLevel, _windowsInstallerClient, _nexClient) { InstallerRecords = _windowsInstallerClient.GetRecords(), Operation = operation }); }
public CreatePackageManifestTask(string targetFile, PackageManifest manifest) { TaskName = "Creating manifest file..."; ActionName = "Create manifest file"; TargetFile = targetFile; TargetFile = targetFile; Manifest = manifest; }
public static PackageSpec ToPackageSpec(this PackageManifest manifest) //, NuGet.Frameworks.NuGetFramework framework) { var spec = manifest.Adapt <PackageSpec>(); //spec.Framework = framework; return(spec); }
public void ExtractManifest() { PackageManifest manifest = Extractor.ExtractManifest(Path.Combine(DataDirectory, "Package", "package.zip")); Assert.NotNull(manifest); Assert.Equal("DefaultPlugin", manifest.Title); Assert.Equal(3, manifest.Files.Count); }
public void fileset_for_searching() { var fileSet = PackageManifest.FileSetForSearching(); fileSet.DeepSearch.ShouldBeTrue(); fileSet.Include.ShouldEqual(PackageManifest.FILE); fileSet.Exclude.ShouldBeNull(); }
public void should_not_serialize_is_latest() { var manifest = new PackageManifest(); var yaml = manifest.ToYaml(); yaml.Should().NotContain("isLatest"); }
public void PrintManifest(PackageManifest manifest) { Console.WriteLine("==============================================="); Console.WriteLine(); Console.WriteLine(manifest.ToYaml()); Console.WriteLine(); Console.WriteLine("==============================================="); }
public void AddConfigFiles(CreatePackageInput input, IZipFile zipFile, PackageManifest manifest) { zipFile.AddFiles(new ZipFolderRequest(){ FileSet = manifest.ConfigFileSet, RootDirectory = input.PackageFolder, ZipDirectory = BottleFiles.ConfigFolder }); }
public void AddDataFiles(CreatePackageInput input, IZipFile zipFile, PackageManifest manifest) { zipFile.AddFiles(new ZipFolderRequest() { FileSet = manifest.DataFileSet, ZipDirectory = BottleFiles.DataFolder, RootDirectory = Path.Combine(input.PackageFolder, BottleFiles.DataFolder) }); }
public void ExtractManifestToFile() { string inputFile = Path.Combine(DataDirectory, "Package", "package.zip"); string outputFile = Path.Combine(TempDirectory, "manifest.json"); PackageManifest manifest = Extractor.ExtractManifest(inputFile, outputFile); Assert.True(File.Exists(outputFile)); }
public void Initialize(PackageManifest packageManifest, string installerPath) { if (InstallerPath != null && BuildInfo.IsDebug) { throw new InvalidOperationException(@"Can't reuse installer."); } InstallerPath = installerPath; }
public void AddConfigFiles(CreateBottleInput input, IZipFile zipFile, PackageManifest manifest) { ConsoleWriter.Write(" Adding Config folder for " + BottleFiles.ConfigFiles); zipFile.AddFiles(new ZipFolderRequest(){ FileSet = BottleFiles.ConfigFiles, RootDirectory = input.PackageFolder, ZipDirectory = BottleFiles.ConfigFolder }); }
public void WriteAssembliesNotFound(AssemblyFiles theAssemblyFiles, PackageManifest manifest, CreatePackageInput input) { Console.WriteLine("Did not locate all designated assemblies at {0}", input.PackageFolder); Console.WriteLine("Looking for these assemblies in the package manifest file:"); manifest.Assemblies.Each(name => Console.WriteLine(" " + name)); Console.WriteLine("But only found:"); if(!theAssemblyFiles.Files.Any()) Console.WriteLine(" Found no files"); theAssemblyFiles.Files.Each(file => Console.WriteLine(" " + file)); }
public void set_role_to_module() { var manifest = new PackageManifest(); manifest.SetRole(BottleRoles.Module); manifest.Role.ShouldEqual(BottleRoles.Module); manifest.ContentFileSet.ShouldNotBeNull(); manifest.ContentFileSet.Include.ShouldContain("*.as*x"); }
public void set_role_to_config() { var manifest = new PackageManifest(); manifest.SetRole(BottleRoles.Config); manifest.Role.ShouldEqual(BottleRoles.Config); manifest.ContentFileSet.ShouldBeNull(); manifest.Assemblies.Any().ShouldBeFalse(); }
public void read_config_manifest_from_file() { var manifest = new PackageManifest(); manifest.SetRole(BottleRoles.Config); var system = new FileSystem(); system.WriteObjectToFile("manifest.xml", manifest); var manifest2 = system.LoadFromFile<PackageManifest>("manifest.xml"); manifest2.ContentFileSet.ShouldBeNull(); }
public void set_role_to_data() { var manifest = new PackageManifest(); manifest.SetRole(BottleRoles.Data); manifest.ContentFileSet.ShouldBeNull(); manifest.ConfigFileSet.ShouldBeNull(); manifest.DataFileSet.DeepSearch.ShouldBeTrue(); manifest.DataFileSet.Include.ShouldEqual("*.*"); }
public void AddContentFiles(CreatePackageInput input, IZipFile zipFile, PackageManifest manifest) { manifest.ContentFileSet.AppendExclude(FileSystem.Combine("bin","*.*")); zipFile.AddFiles(new ZipFolderRequest() { FileSet = manifest.ContentFileSet, ZipDirectory = BottleFiles.WebContentFolder, RootDirectory = input.PackageFolder }); }
//REVIEW: why is this reading? public void ReadFrom(string fileName, Action<PackageManifest> onCreation) { if (_fileSystem.FileExists(fileName)) { _manifest = _fileSystem.LoadFromFile<PackageManifest>(fileName); } else { _manifest = new PackageManifest(); onCreation(_manifest); } }
public virtual IEnumerable<BottleExplosionRequest> DetermineExplosionRequests(PackageManifest manifest) { switch (manifest.Role) { case BottleRoles.Binaries: yield return new BottleExplosionRequest { BottleDirectory = BottleFiles.BinaryFolder, BottleName = manifest.Name, DestinationDirectory = FileSystem.Combine(_physicalPath, BottleFiles.BinaryFolder) }; break; case BottleRoles.Config: yield return new BottleExplosionRequest() { BottleDirectory = BottleFiles.ConfigFolder, BottleName = manifest.Name, DestinationDirectory = FileSystem.Combine(_physicalPath, BottleFiles.ConfigFolder) }; break; case BottleRoles.Module: yield return new BottleExplosionRequest { BottleDirectory = BottleFiles.BinaryFolder, BottleName = manifest.Name, DestinationDirectory = _physicalPath.AppendPath(BottleFiles.BinaryFolder) }; break; case BottleRoles.Application: yield return new BottleExplosionRequest { BottleName = manifest.Name, BottleDirectory = BottleFiles.BinaryFolder, DestinationDirectory = FileSystem.Combine(_physicalPath, BottleFiles.BinaryFolder) }; yield return new BottleExplosionRequest { BottleName = manifest.Name, BottleDirectory = BottleFiles.WebContentFolder, DestinationDirectory = _physicalPath }; break; default: yield break; } }
public void BeforeEach() { var fs = new FileSystem(); fs.DeleteDirectory(thePathToScan); fs.CreateDirectory(thePathToScan); fs.CreateDirectory(thePathToScan, "bin"); theLoader = new SolutionDirectoryPackageLoader(thePathToScan.ToFullPath()); var manifest = new PackageManifest(); manifest.Name = "test-mani"; fs.PersistToFile(manifest, thePathToScan, PackageManifest.FILE); }
public bool CreatePackage(CreateBottleInput input, PackageManifest manifest) { var binFolder = _fileSystem.FindBinaryDirectory(input.PackageFolder, input.TargetFlag); var assemblies = _assemblyFinder.FindAssemblies(binFolder, manifest.Assemblies); if (assemblies.Success) { writeZipFile(input, manifest, assemblies); return true; } _logger.WriteAssembliesNotFound(assemblies, manifest, input, binFolder); return false; }
public void WriteAssembliesNotFound(AssemblyFiles theAssemblyFiles, PackageManifest manifest, CreateBottleInput input, string binFolder) { ConsoleWriter.Write("Did not locate all designated assemblies at '{0}'", binFolder); ConsoleWriter.Write("Looking for these assemblies in the package manifest file:"); manifest.Assemblies.Each(name => ConsoleWriter.Write(" " + name)); ConsoleWriter.Write("But only found:"); if(!theAssemblyFiles.Files.Any()) ConsoleWriter.Write(" Found no files"); theAssemblyFiles.Files.Each(file => ConsoleWriter.Write(" " + file)); ConsoleWriter.Write("Missing"); theAssemblyFiles.MissingAssemblies.Each(file => ConsoleWriter.Write(" " + file)); throw new ApplicationException("Invalid package manifest or missing files"); }
public void CreatePackage(CreatePackageInput input, PackageManifest manifest) { var binFolder = _fileSystem.FindBinaryDirectory(input.PackageFolder, input.TargetFlag); var assemblies = _assemblyFinder.FindAssemblies(binFolder, manifest.Assemblies); if (assemblies.Success) { writeZipFile(input, manifest, assemblies); } else { _logger.WriteAssembliesNotFound(assemblies, manifest, input); } }
public void load_all_packages_by_reading_the_include_folder() { var includes = new PackageManifest(); includes.AddLink("../TestPackage1"); new FileSystem().PersistToFile(includes, "../../".ToFullPath(), PackageManifest.FILE); var assemblyLoader = new AssemblyLoader(new PackagingDiagnostics()); assemblyLoader.AssemblyFileLoader = file => Assembly.Load(File.ReadAllBytes(file)); var package = reader.Load(new PackageLog()).Single(); assemblyLoader.LoadAssembliesFromPackage(package); assemblyLoader.Assemblies.Single().GetName().Name.ShouldEqual("TestPackage1"); }
public AssemblyPackageInfo(Assembly assembly) { _manifest = new AssemblyPackageManifestFactory().Extract(assembly); _inner = new Lazy<PackageInfo>(() => { var inner = new PackageInfo(_manifest); var exploder = BottleExploder.GetPackageExploder(new FileSystem()); exploder.ExplodeAssembly(PackageRegistry.GetApplicationDirectory(), assembly, inner); return inner; }); _assembly = assembly; }
public void SetUp() { theFileSystem = MockRepository.GenerateMock<IFileSystem>(); theInput = new AssembliesInput{ Directory = "directory1", FileNameFlag = null }; thePackageManifest = new PackageManifest(){ Name = "the package" }; theApplicationManifest = new PackageManifest(){ Name = "the application" }; }
public void AddConfigFiles(CreateBottleInput input, IZipFile zipFile, PackageManifest manifest) { if (manifest.ConfigFileSet == null) { ConsoleWriter.Write(" No config files"); return; } ConsoleWriter.Write(" Adding Config folder for " + manifest.ConfigFileSet); zipFile.AddFiles(new ZipFolderRequest(){ FileSet = manifest.ConfigFileSet, RootDirectory = input.PackageFolder, ZipDirectory = BottleFiles.ConfigFolder }); }
public void creates_a_single_explosion_request_for_a_module() { var manifest = new PackageManifest(){ Name = "the manifest", Role = BottleRoles.Module }; var destination = new CopyAllModulesDestination("something"); var request = destination.DetermineExplosionRequests(manifest).Single(); // copies the bottle as is request.BottleDirectory.ShouldBeNull(); request.BottleName.ShouldEqual(manifest.Name); request.DestinationDirectory.ShouldEqual("something"); }
public void AddDataFiles(CreateBottleInput input, IZipFile zipFile, PackageManifest manifest) { if (manifest.DataFileSet == null) { ConsoleWriter.Write(" No data files"); return; } ConsoleWriter.Write(" Adding Data folder for " + manifest.DataFileSet); zipFile.AddFiles(new ZipFolderRequest() { FileSet = manifest.DataFileSet, ZipDirectory = BottleFiles.DataFolder, RootDirectory = Path.Combine(input.PackageFolder, BottleFiles.DataFolder) }); }
public void ModulePackage() { var dest = new TopshelfBottleDestination("bob"); var mani = new PackageManifest() { Name = "hi", Role = BottleRoles.Module }; var requests = dest.DetermineExplosionRequests(mani); requests.Count().ShouldEqual(1); var req = requests.Single(); req.BottleDirectory.ShouldEqual(BottleFiles.BinaryFolder); req.BottleName = mani.Name; req.DestinationDirectory = "bob".AppendPath(TopshelfPackageLoader.TopshelfPackagesFolder); }
public void use_the_file_name_if_it_is_given_and_the_manifest_exists_at_that_file() { var manifest = new PackageManifest(){ Name = "special" }; theInput.FileNameFlag = "special.xml"; theFileSystem.Stub(x => x.FileExists(theInput.Directory, theInput.FileNameFlag)) .Return(true); theFileSystem.Stub(x => x.LoadFromFile<PackageManifest>(theInput.Directory, theInput.FileNameFlag)) .Return(manifest); theInput.FindManifestAndBinaryFolders(theFileSystem); theInput.Manifest.ShouldBeTheSameAs(manifest); }
public void AddContentFiles(CreateBottleInput input, IZipFile zipFile, PackageManifest manifest) { if (manifest.ContentFileSet == null) { ConsoleWriter.Write(" No WebContent files"); return; } ConsoleWriter.Write(" Adding WebContent folder for " + manifest.ContentFileSet); manifest.ContentFileSet.AppendExclude(FileSystem.Combine("bin","*.*")); zipFile.AddFiles(new ZipFolderRequest() { FileSet = manifest.ContentFileSet, ZipDirectory = BottleFiles.WebContentFolder, RootDirectory = input.PackageFolder }); }