public void CreateFiles(string rpm, string analyzerName)
        {
            using (Stream stream = File.OpenRead(rpm))
            {
                var originalPackage = RpmPackageReader.Read(stream);

                using (var payloadStream = RpmPayloadReader.GetDecompressedPayloadStream(originalPackage))
                    using (var cpio = new CpioFile(payloadStream, false))
                    {
                        IFileAnalyzer analyzer = new FileAnalyzer();

                        switch (analyzerName)
                        {
                        case "plist":
                            analyzer = new PlistFileAnalyzer();
                            break;

                        case "dotnet":
                            analyzer = new DotnetFileAnalyzer();
                            break;
                        }

                        RpmPackageCreator creator = new RpmPackageCreator(analyzer);
                        ArchiveBuilder    builder = new ArchiveBuilder(analyzer);
                        var entries = builder.FromCpio(cpio);
                        var files   = creator.CreateFiles(entries);

                        var originalMetadata = new RpmMetadata(originalPackage);

                        var originalFiles = originalMetadata.Files.ToArray();

                        Assert.Equal(originalFiles.Length, files.Count);

                        for (int i = 0; i < originalFiles.Length; i++)
                        {
                            var originalFile = originalFiles[i];
                            var file         = files[i];

                            Assert.Equal(originalFile.Class, file.Class);
                            Assert.Equal(originalFile.Color, file.Color);
                            Assert.Equal(originalFile.Requires, file.Requires);
                            Assert.Equal(originalFile.Provides, file.Provides);
                            Assert.Equal(originalFile.Device, file.Device);
                            Assert.Equal(originalFile.Flags, file.Flags);
                            Assert.Equal(originalFile.GroupName, file.GroupName);
                            Assert.Equal(originalFile.Inode, file.Inode);
                            Assert.Equal(originalFile.Lang, file.Lang);
                            Assert.Equal(originalFile.LinkTo, file.LinkTo);
                            Assert.Equal(originalFile.MD5Hash, file.MD5Hash);
                            Assert.Equal(originalFile.Mode, file.Mode);
                            Assert.Equal(originalFile.ModifiedTime, file.ModifiedTime);
                            Assert.Equal(originalFile.Name, file.Name);
                            Assert.Equal(originalFile.Rdev, file.Rdev);
                            Assert.Equal(originalFile.Size, file.Size);
                            Assert.Equal(originalFile.UserName, file.UserName);
                            Assert.Equal(originalFile.VerifyFlags, file.VerifyFlags);
                        }
                    }
            }
        }
        public void CreatePackageTest()
        {
            var krgen         = PgpSigner.GenerateKeyRingGenerator("dotnet", "dotnet");
            var secretKeyRing = krgen.GenerateSecretKeyRing();
            var privateKey    = secretKeyRing.GetSecretKey().ExtractPrivateKey("dotnet".ToCharArray());
            var publicKey     = secretKeyRing.GetPublicKey();

            using (Stream stream = File.OpenRead(@"Rpm\libplist-2.0.1.151-1.1.x86_64.rpm"))
                using (var targetStream = File.Open(@"RpmPackageCreatorTests_CreateTest.rpm", FileMode.Create, FileAccess.ReadWrite, FileShare.None))
                {
                    var originalPackage         = RpmPackageReader.Read(stream);
                    List <ArchiveEntry> archive = null;

                    using (var decompressedPayloadStream = RpmPayloadReader.GetDecompressedPayloadStream(originalPackage))
                        using (CpioFile cpio = new CpioFile(decompressedPayloadStream, leaveOpen: false))
                        {
                            ArchiveBuilder builder = new ArchiveBuilder();
                            archive = builder.FromCpio(cpio);
                        }

                    using (var decompressedPayloadStream = RpmPayloadReader.GetDecompressedPayloadStream(originalPackage))
                        using (var payloadStream = new MemoryStream())
                        {
                            decompressedPayloadStream.CopyTo(payloadStream);
                            payloadStream.Position = 0;

                            RpmPackageCreator creator = new RpmPackageCreator(new PlistFileAnalyzer());
                            creator.CreatePackage(
                                archive,
                                payloadStream,
                                "libplist",
                                "2.0.1.151",
                                "x86_64",
                                "1.1",
                                false,
                                null,
                                false,
                                null,
                                null,
                                null,
                                (metadata) => PlistMetadata.ApplyDefaultMetadata(metadata),
                                privateKey,
                                targetStream);
                        }
                }

            using (var targetStream = File.Open(@"RpmPackageCreatorTests_CreateTest.rpm", FileMode.Open, FileAccess.Read, FileShare.None))
            {
                var package = RpmPackageReader.Read(targetStream);

                var metadata  = new RpmMetadata(package);
                var signature = new RpmSignature(package);

                Assert.True(signature.Verify(publicKey));
            }
        }
        public void CalculateOffsetTest()
        {
            using (Stream stream = File.OpenRead(@"Rpm/libplist-2.0.1.151-1.1.x86_64.rpm"))
            {
                var originalPackage = RpmPackageReader.Read(stream);

                using (var payloadStream = RpmPayloadReader.GetDecompressedPayloadStream(originalPackage))
                    using (var cpio = new CpioFile(payloadStream, false))
                    {
                        ArchiveBuilder    builder = new ArchiveBuilder(new PlistFileAnalyzer());
                        RpmPackageCreator creator = new RpmPackageCreator(new PlistFileAnalyzer());
                        var entries = builder.FromCpio(cpio);
                        var files   = creator.CreateFiles(entries);

                        // Core routine to populate files and dependencies
                        RpmPackage package  = new RpmPackage();
                        var        metadata = new PublicRpmMetadata(package);
                        metadata.Name    = "libplist";
                        metadata.Version = "2.0.1.151";
                        metadata.Arch    = "x86_64";
                        metadata.Release = "1.1";

                        creator.AddPackageProvides(metadata);
                        creator.AddLdDependencies(metadata);

                        metadata.Files = files;
                        creator.AddRpmDependencies(metadata, null);

                        PlistMetadata.ApplyDefaultMetadata(metadata);

                        metadata.Vendor              = "obs://build.opensuse.org/home:qmfrederik";
                        metadata.Description         = "libplist is a library for manipulating Apple Binary and XML Property Lists";
                        metadata.Url                 = "http://www.libimobiledevice.org/";
                        metadata.Size                = 0x26e6d;
                        metadata.ImmutableRegionSize = -976;

                        creator.CalculateHeaderOffsets(package);

                        foreach (var record in originalPackage.Header.Records)
                        {
                            if (record.Key == IndexTag.RPMTAG_HEADERIMMUTABLE)
                            {
                                continue;
                            }

                            this.AssertTagOffsetEqual(record.Key, originalPackage, package);
                        }

                        this.AssertTagOffsetEqual(IndexTag.RPMTAG_HEADERIMMUTABLE, originalPackage, package);
                    }
            }
        }
Пример #4
0
        public void CreatePackageMetadata()
        {
            using (Stream stream = File.OpenRead(@"Rpm/libplist-2.0.1.151-1.1.x86_64.rpm"))
            {
                var originalPackage = RpmPackageReader.Read(stream);

                using (var payloadStream = RpmPayloadReader.GetDecompressedPayloadStream(originalPackage))
                    using (var cpio = new CpioFile(payloadStream, false))
                    {
                        ArchiveBuilder    builder = new ArchiveBuilder(new PlistFileAnalyzer());
                        RpmPackageCreator creator = new RpmPackageCreator(new PlistFileAnalyzer());
                        var entries = builder.FromCpio(cpio);
                        var files   = creator.CreateFiles(entries);

                        // Core routine to populate files and dependencies
                        RpmPackage package  = new RpmPackage();
                        var        metadata = new PublicRpmMetadata(package);
                        metadata.Name    = "libplist";
                        metadata.Version = "2.0.1.151";
                        metadata.Arch    = "x86_64";
                        metadata.Release = "1.1";

                        creator.AddPackageProvides(metadata);
                        creator.AddLdDependencies(metadata);

                        metadata.Files = files;
                        creator.AddRpmDependencies(metadata, null);

                        PlistMetadata.ApplyDefaultMetadata(metadata);

                        metadata.Size = 0x26e6d;
                        metadata.ImmutableRegionSize = -976;

                        foreach (var record in originalPackage.Header.Records)
                        {
                            this.AssertTagEqual(record.Key, originalPackage, package);
                        }
                    }
            }
        }
        public override bool Execute()
        {
            this.Log.LogMessage(MessageImportance.Normal, "Creating RPM package '{0}' from folder '{1}'", this.RpmPath, this.PublishDir);

            var krgen         = PgpSigner.GenerateKeyRingGenerator("dotnet", "dotnet");
            var secretKeyRing = krgen.GenerateSecretKeyRing();
            var privateKey    = secretKeyRing.GetSecretKey().ExtractPrivateKey("dotnet".ToCharArray());
            var publicKey     = secretKeyRing.GetPublicKey();

            using (var targetStream = File.Open(this.RpmPath, FileMode.Create, FileAccess.ReadWrite, FileShare.None))
                using (var cpioStream = File.Open(this.CpioPath, FileMode.Create, FileAccess.ReadWrite, FileShare.None))
                {
                    ArchiveBuilder archiveBuilder = new ArchiveBuilder();
                    var            archiveEntries = archiveBuilder.FromDirectory(
                        this.PublishDir,
                        this.Prefix,
                        this.Content);

                    archiveEntries.AddRange(archiveBuilder.FromLinuxFolders(this.LinuxFolders));
                    archiveEntries = archiveEntries
                                     .OrderBy(e => e.TargetPathWithFinalSlash, StringComparer.Ordinal)
                                     .ToList();

                    CpioFileCreator cpioCreator = new CpioFileCreator();
                    cpioCreator.FromArchiveEntries(
                        archiveEntries,
                        cpioStream);
                    cpioStream.Position = 0;

                    // Prepare the list of dependencies
                    PackageDependency[] dependencies = Array.Empty <PackageDependency>();

                    if (this.RpmDependencies != null)
                    {
                        dependencies = this.RpmDependencies.Select(
                            d => new PackageDependency(
                                d.ItemSpec,
                                RpmSense.RPMSENSE_EQUAL | RpmSense.RPMSENSE_GREATER,
                                d.GetVersion()))
                                       .ToArray();
                    }

                    RpmPackageCreator rpmCreator = new RpmPackageCreator();
                    rpmCreator.CreatePackage(
                        archiveEntries,
                        cpioStream,
                        this.PackageName,
                        this.Version,
                        "x86_64",
                        this.Release,
                        this.CreateUser,
                        this.UserName,
                        this.InstallService,
                        this.ServiceName,
                        this.Prefix,
                        dependencies,
                        null,
                        privateKey,
                        targetStream);
                }

            this.Log.LogMessage(MessageImportance.Normal, "Created RPM package '{0}' from folder '{1}'", this.RpmPath, this.PublishDir);
            return(true);
        }
        public void CreatePackageBinaryTest()
        {
            var pgpSignatureData = File.ReadAllBytes("Rpm/RpmSigTag_Pgp.bin");
            var rsaSignatureData = File.ReadAllBytes("Rpm/RpmSigTag_Rsa.bin");

            var signer = new DummySigner();

            signer.Add("D72D1E8A9326431472A1E39E1B7916AD07CCC31B", rsaSignatureData);
            signer.Add("A0A33779FBBED565A15FA85BAFBD1473E00F1257", pgpSignatureData);
            signer.Add("5E24172F773FEB67FC0BF4831BB4E8A75B4554EF", pgpSignatureData);

            using (Stream stream = File.OpenRead(@"Rpm/libplist-2.0.1.151-1.1.x86_64.rpm"))
                using (var targetStream = File.Open(@"RpmPackageCreatorTests_CreateBinaryTest.rpm", FileMode.Create, FileAccess.ReadWrite, FileShare.None))
                {
                    var originalPackage         = RpmPackageReader.Read(stream);
                    List <ArchiveEntry> archive = null;

                    using (var decompressedPayloadStream = RpmPayloadReader.GetDecompressedPayloadStream(originalPackage))
                        using (CpioFile cpio = new CpioFile(decompressedPayloadStream, leaveOpen: false))
                        {
                            ArchiveBuilder builder = new ArchiveBuilder();
                            archive = builder.FromCpio(cpio);
                        }

                    using (var compressedPayloadStream = RpmPayloadReader.GetCompressedPayloadStream(originalPackage))
                    {
                        RpmPackageCreator creator = new RpmPackageCreator(new PlistFileAnalyzer());
                        creator.CreatePackage(
                            archive,
                            compressedPayloadStream,
                            "libplist",
                            "2.0.1.151",
                            "x86_64",
                            "1.1",
                            false,
                            null,
                            false,
                            null,
                            null,
                            null,
                            null,
                            null,
                            null,
                            null,
                            (metadata) => PlistMetadata.ApplyDefaultMetadata(metadata),
                            signer,
                            targetStream,
                            includeVersionInName: true,
                            payloadIsCompressed: true);
                    }
                }

            using (var originalStream = File.OpenRead(@"Rpm/libplist-2.0.1.151-1.1.x86_64.rpm"))
                using (var targetStream = File.Open(@"RpmPackageCreatorTests_CreateBinaryTest.rpm", FileMode.Open, FileAccess.Read, FileShare.None))
                {
                    var originalPackage = RpmPackageReader.Read(originalStream);
                    var package         = RpmPackageReader.Read(targetStream);

                    RpmDumper.Dump(originalPackage, "RpmPackageCreatorTests_CreateBinaryTest_original.txt");
                    RpmDumper.Dump(package, "RpmPackageCreatorTests_CreateBinaryTest_reconstructed.txt");

                    var metadata  = new RpmMetadata(package);
                    var signature = new RpmSignature(package);

                    foreach (var record in originalPackage.Signature.Records)
                    {
                        this.AssertTagEqual(record.Key, originalPackage, package);
                    }

                    originalStream.Position = 0;
                    targetStream.Position   = 0;

                    int    index          = 0;
                    byte[] originalBuffer = new byte[1024];
                    byte[] targetBuffer   = new byte[1024];

                    while (originalStream.Position < originalStream.Length)
                    {
                        originalStream.Read(originalBuffer, 0, originalBuffer.Length);
                        targetStream.Read(targetBuffer, 0, targetBuffer.Length);

                        Assert.Equal(originalBuffer, targetBuffer);

                        index += originalBuffer.Length;
                    }
                }
        }
        public void CreatePackageTest()
        {
            var          krgen            = PgpSigner.GenerateKeyRingGenerator("dotnet", "dotnet");
            var          secretKeyRing    = krgen.GenerateSecretKeyRing();
            var          privateKey       = secretKeyRing.GetSecretKey().ExtractPrivateKey("dotnet".ToCharArray());
            var          publicKey        = secretKeyRing.GetPublicKey();
            const string preInstScript    = "echo preinst\n";
            const string postInstScript   = "echo postinst\n";
            const string preRemoveScript  = "echo preremove\n";
            const string postRemoveScript = "echo postremove\n";
            const string nameString       = "libplist";
            const string versionString    = "2.0.1.151";
            const string releaseString    = "1.1";
            const string archString       = "x86_64";

            using (Stream stream = File.OpenRead($"Rpm/{nameString}-{versionString}-{releaseString}.{archString}.rpm"))
                using (var targetStream = File.Open(@"RpmPackageCreatorTests_CreateTest.rpm", FileMode.Create, FileAccess.ReadWrite, FileShare.None))
                {
                    var originalPackage         = RpmPackageReader.Read(stream);
                    List <ArchiveEntry> archive = null;

                    using (var decompressedPayloadStream = RpmPayloadReader.GetDecompressedPayloadStream(originalPackage))
                        using (CpioFile cpio = new CpioFile(decompressedPayloadStream, leaveOpen: false))
                        {
                            ArchiveBuilder builder = new ArchiveBuilder();
                            archive = builder.FromCpio(cpio);
                        }

                    using (var decompressedPayloadStream = RpmPayloadReader.GetDecompressedPayloadStream(originalPackage))
                        using (var payloadStream = new MemoryStream())
                        {
                            decompressedPayloadStream.CopyTo(payloadStream);
                            payloadStream.Position = 0;

                            RpmPackageCreator creator = new RpmPackageCreator(new PlistFileAnalyzer());
                            creator.CreatePackage(
                                archive,
                                payloadStream,
                                nameString,
                                versionString,
                                archString,
                                releaseString,
                                false,
                                null,
                                false,
                                null,
                                null,
                                preInstScript,
                                postInstScript,
                                preRemoveScript,
                                postRemoveScript,
                                null,
                                (metadata) => PlistMetadata.ApplyDefaultMetadata(metadata),
                                privateKey,
                                targetStream);
                        }
                }

            using (var targetStream = File.Open(@"RpmPackageCreatorTests_CreateTest.rpm", FileMode.Open, FileAccess.Read, FileShare.None))
            {
                var package = RpmPackageReader.Read(targetStream);

                var metadata = new RpmMetadata(package);
                Assert.Equal(metadata.Version, versionString);
                Assert.Equal(metadata.Name, nameString);
                Assert.Equal(metadata.Arch, archString);
                Assert.Equal(metadata.Release, releaseString);
                Assert.StartsWith(preInstScript, metadata.PreIn);
                Assert.StartsWith(postInstScript, metadata.PostIn);
                Assert.StartsWith(preRemoveScript, metadata.PreUn);
                Assert.StartsWith(postRemoveScript, metadata.PostUn);
                var signature = new RpmSignature(package);

                Assert.True(signature.Verify(publicKey));
            }
        }
        public void CalculateSignatureTest()
        {
            using (Stream stream = File.OpenRead(@"Rpm/libplist-2.0.1.151-1.1.x86_64.rpm"))
            {
                var originalPackage = RpmPackageReader.Read(stream);

                RpmPackageCreator    creator = new RpmPackageCreator(new PlistFileAnalyzer());
                Collection <RpmFile> files;

                using (var payloadStream = RpmPayloadReader.GetDecompressedPayloadStream(originalPackage))
                    using (var cpio = new CpioFile(payloadStream, false))
                    {
                        ArchiveBuilder builder = new ArchiveBuilder(new PlistFileAnalyzer());
                        var            entries = builder.FromCpio(cpio);
                        files = creator.CreateFiles(entries);
                    }

                // Core routine to populate files and dependencies
                RpmPackage package  = new RpmPackage();
                var        metadata = new PublicRpmMetadata(package);
                metadata.Name    = "libplist";
                metadata.Version = "2.0.1.151";
                metadata.Arch    = "x86_64";
                metadata.Release = "1.1";

                creator.AddPackageProvides(metadata);
                creator.AddLdDependencies(metadata);

                metadata.Files = files;
                creator.AddRpmDependencies(metadata, null);

                PlistMetadata.ApplyDefaultMetadata(metadata);

                creator.CalculateHeaderOffsets(package);

                // Make sure the header is really correct
                using (Stream originalHeaderStream = new SubStream(
                           originalPackage.Stream,
                           originalPackage.HeaderOffset,
                           originalPackage.PayloadOffset - originalPackage.HeaderOffset,
                           leaveParentOpen: true,
                           readOnly: true))
                    using (Stream headerStream = creator.GetHeaderStream(package))
                    {
                        byte[] originalData = new byte[originalHeaderStream.Length];
                        originalHeaderStream.Read(originalData, 0, originalData.Length);

                        byte[] data = new byte[headerStream.Length];
                        headerStream.Read(data, 0, data.Length);

                        int      delta     = 0;
                        int      dataDelta = 0;
                        IndexTag tag;
                        for (int i = 0; i < data.Length; i++)
                        {
                            if (originalData[i] != data[i])
                            {
                                delta     = i;
                                dataDelta = delta - package.Header.Records.Count * Marshal.SizeOf <IndexHeader>();
                                tag       = package.Header.Records.OrderBy(r => r.Value.Header.Offset).Last(r => r.Value.Header.Offset <= dataDelta).Key;

                                break;
                            }
                        }

                        Assert.Equal(originalData, data);
                    }

                var krgen         = PgpSigner.GenerateKeyRingGenerator("dotnet", "dotnet");
                var secretKeyRing = krgen.GenerateSecretKeyRing();
                var privateKey    = secretKeyRing.GetSecretKey().ExtractPrivateKey("dotnet".ToCharArray());

                using (var payload = RpmPayloadReader.GetCompressedPayloadStream(originalPackage))
                {
                    // Header should be OK now (see previous test), so now get the signature block and the
                    // trailer
                    creator.CalculateSignature(package, privateKey, payload);
                    creator.CalculateSignatureOffsets(package);

                    foreach (var record in originalPackage.Signature.Records)
                    {
                        if (record.Key == SignatureTag.RPMTAG_HEADERSIGNATURES)
                        {
                            continue;
                        }

                        this.AssertTagEqual(record.Key, originalPackage, package);
                    }

                    this.AssertTagEqual(SignatureTag.RPMTAG_HEADERSIGNATURES, originalPackage, package);
                }
            }
        }
Пример #9
0
        public void SetFilesTest()
        {
            using (Stream stream = File.OpenRead(@"Rpm/libplist-2.0.1.151-1.1.x86_64.rpm"))
            {
                var originalPackage = RpmPackageReader.Read(stream);
                var package         = new RpmPackage();

                using (var payloadStream = RpmPayloadReader.GetDecompressedPayloadStream(originalPackage))
                    using (var cpio = new CpioFile(payloadStream, false))
                    {
                        ArchiveBuilder    builder = new ArchiveBuilder(new PlistFileAnalyzer());
                        RpmPackageCreator creator = new RpmPackageCreator(new PlistFileAnalyzer());
                        var entries = builder.FromCpio(cpio);
                        var files   = creator.CreateFiles(entries);

                        var metadata = new PublicRpmMetadata(package);
                        metadata.Name    = "libplist";
                        metadata.Version = "2.0.1.151";
                        metadata.Arch    = "x86_64";
                        metadata.Release = "1.1";

                        creator.AddPackageProvides(metadata);
                        creator.AddLdDependencies(metadata);

                        metadata.Files = files;
                        creator.AddRpmDependencies(metadata, null);

                        this.AssertTagEqual(IndexTag.RPMTAG_FILESIZES, originalPackage, package);
                        this.AssertTagEqual(IndexTag.RPMTAG_FILEMODES, originalPackage, package);
                        this.AssertTagEqual(IndexTag.RPMTAG_FILERDEVS, originalPackage, package);
                        this.AssertTagEqual(IndexTag.RPMTAG_FILEMTIMES, originalPackage, package);
                        this.AssertTagEqual(IndexTag.RPMTAG_FILEDIGESTS, originalPackage, package);
                        this.AssertTagEqual(IndexTag.RPMTAG_FILELINKTOS, originalPackage, package);
                        this.AssertTagEqual(IndexTag.RPMTAG_FILEFLAGS, originalPackage, package);
                        this.AssertTagEqual(IndexTag.RPMTAG_FILEUSERNAME, originalPackage, package);
                        this.AssertTagEqual(IndexTag.RPMTAG_FILEGROUPNAME, originalPackage, package);
                        this.AssertTagEqual(IndexTag.RPMTAG_FILEVERIFYFLAGS, originalPackage, package);
                        this.AssertTagEqual(IndexTag.RPMTAG_FILEDEVICES, originalPackage, package);
                        this.AssertTagEqual(IndexTag.RPMTAG_FILEINODES, originalPackage, package);
                        this.AssertTagEqual(IndexTag.RPMTAG_FILELANGS, originalPackage, package);
                        this.AssertTagEqual(IndexTag.RPMTAG_FILECOLORS, originalPackage, package);

                        this.AssertTagEqual(IndexTag.RPMTAG_FILECLASS, originalPackage, package);
                        this.AssertTagEqual(IndexTag.RPMTAG_CLASSDICT, originalPackage, package);

                        this.AssertTagEqual(IndexTag.RPMTAG_BASENAMES, originalPackage, package);
                        this.AssertTagEqual(IndexTag.RPMTAG_DIRINDEXES, originalPackage, package);
                        this.AssertTagEqual(IndexTag.RPMTAG_DIRNAMES, originalPackage, package);

                        // The require and provides records contain file dependencies, as well as package dependencies.
                        // That's why there's a call to AddLdDependencies and AddRpmDependencies, to make sure
                        // these dependencies are written out in order.
                        this.AssertTagEqual(IndexTag.RPMTAG_REQUIRENAME, originalPackage, package);
                        this.AssertTagEqual(IndexTag.RPMTAG_REQUIREFLAGS, originalPackage, package);
                        this.AssertTagEqual(IndexTag.RPMTAG_REQUIREVERSION, originalPackage, package);
                        this.AssertTagEqual(IndexTag.RPMTAG_PROVIDENAME, originalPackage, package);
                        this.AssertTagEqual(IndexTag.RPMTAG_PROVIDEFLAGS, originalPackage, package);
                        this.AssertTagEqual(IndexTag.RPMTAG_REQUIREVERSION, originalPackage, package);
                        this.AssertTagEqual(IndexTag.RPMTAG_FILEDEPENDSN, originalPackage, package);
                        this.AssertTagEqual(IndexTag.RPMTAG_FILEDEPENDSX, originalPackage, package);
                        this.AssertTagEqual(IndexTag.RPMTAG_DEPENDSDICT, originalPackage, package);
                    }
            }
        }
Пример #10
0
        public static void HandlerItem(bool dev, PublishDirInfo item)
        {
            var rpmPath = GetPackPath(dev, item, FileEx.RPM);

            //var cpioPath = GetPackPath(item, FileEx.CPIO);

            using var targetStream = File.Open(rpmPath, FileMode.Create, FileAccess.ReadWrite, FileShare.None);
            //using var cpioStream = File.Open(cpioPath, FileMode.Create, FileAccess.ReadWrite, FileShare.None);
            using var cpioStream = new MemoryStream();

            ArchiveBuilder2 archiveBuilder2 = new()
            {
                Log = TaskLoggingHelper.Instance,
            };
            ArchiveBuilder archiveBuilder = archiveBuilder2;

            var archiveEntries = archiveBuilder.FromDirectory(
                item.Path,
                Constants.HARDCODED_APP_NAME,
                LinuxPackConstants.Prefix,
                Array.Empty <ITaskItem>());

            LinuxPackConstants.AddFileNameDesktop(archiveBuilder2, archiveEntries);

            //archiveEntries.AddRange(archiveBuilder.FromLinuxFolders(this.LinuxFolders));

            archiveEntries = archiveEntries
                             .OrderBy(e => e.TargetPathWithFinalSlash, StringComparer.Ordinal)
                             .ToList();

            CpioFileCreator cpioCreator = new CpioFileCreator();

            cpioCreator.FromArchiveEntries(
                archiveEntries,
                cpioStream);
            cpioStream.Position = 0;

            // Prepare the list of dependencies
            List <PackageDependency> dependencies = new List <PackageDependency>();

            if (item.DeploymentMode == DeploymentMode.FDE)
            {
                dependencies.Add(new PackageDependency {
                    Name = LinuxPackConstants.aspnetcore_runtime_6_0
                });
            }

            //if (this.RpmDotNetDependencies != null)
            //{
            //    dependencies.AddRange(
            //        this.RpmDotNetDependencies.Select(
            //            d => GetPackageDependency(d)));
            //}

            //if (this.RpmDependencies != null)
            //{
            //    dependencies.AddRange(
            //        this.RpmDependencies.Select(
            //            d => GetPackageDependency(d)));
            //}

            RpmPackageCreator rpmCreator = new RpmPackageCreator();

            rpmCreator.CreatePackage(
                archiveEntries,
                cpioStream,
                LinuxPackConstants.PackageName,
                Utils.GetVersion(dev),
                RpmTask.GetPackageArchitecture(item.Name),
                LinuxPackConstants.Release,
                LinuxPackConstants.CreateUser,
                LinuxPackConstants.UserName,
                LinuxPackConstants.InstallService,
                LinuxPackConstants.ServiceName,
                LinuxPackConstants.RpmVendor,
                LinuxPackConstants.Description,
                LinuxPackConstants.Url,
                LinuxPackConstants.Prefix,
                LinuxPackConstants.PreInstallScript,
                LinuxPackConstants.PostInstallScript,
                LinuxPackConstants.PreRemoveScript,
                LinuxPackConstants.PostRemoveScript,
                dependencies,
                null !,
                privateKey !,
                targetStream);
        }
Пример #11
0
        public override bool Execute()
        {
            this.Log.LogMessage(MessageImportance.Normal, "Creating RPM package '{0}' from folder '{1}'", this.RpmPath, this.PublishDir);

            var krgen         = PgpSigner.GenerateKeyRingGenerator("dotnet", "dotnet");
            var secretKeyRing = krgen.GenerateSecretKeyRing();
            var privateKey    = secretKeyRing.GetSecretKey().ExtractPrivateKey("dotnet".ToCharArray());
            var publicKey     = secretKeyRing.GetPublicKey();

            using (var targetStream = File.Open(this.RpmPath, FileMode.Create, FileAccess.ReadWrite, FileShare.None))
                using (var cpioStream = File.Open(this.CpioPath, FileMode.Create, FileAccess.ReadWrite, FileShare.None))
                {
                    ArchiveBuilder archiveBuilder = new ArchiveBuilder()
                    {
                        Log = this.Log,
                    };

                    var archiveEntries = archiveBuilder.FromDirectory(
                        this.PublishDir,
                        this.AppHost,
                        this.Prefix,
                        this.Content);

                    archiveEntries.AddRange(archiveBuilder.FromLinuxFolders(this.LinuxFolders));

                    archiveEntries = archiveEntries
                                     .OrderBy(e => e.TargetPathWithFinalSlash, StringComparer.Ordinal)
                                     .ToList();

                    CpioFileCreator cpioCreator = new CpioFileCreator();
                    cpioCreator.FromArchiveEntries(
                        archiveEntries,
                        cpioStream);
                    cpioStream.Position = 0;

                    // Prepare the list of dependencies
                    List <PackageDependency> dependencies = new List <PackageDependency>();

                    if (this.RpmDotNetDependencies != null)
                    {
                        dependencies.AddRange(
                            this.RpmDotNetDependencies.Select(
                                d => GetPackageDependency(d)));
                    }

                    if (this.RpmDependencies != null)
                    {
                        dependencies.AddRange(
                            this.RpmDependencies.Select(
                                d => GetPackageDependency(d)));
                    }

                    RpmPackageCreator rpmCreator = new RpmPackageCreator();
                    rpmCreator.CreatePackage(
                        archiveEntries,
                        cpioStream,
                        this.PackageName,
                        this.Version,
                        !string.IsNullOrEmpty(this.RpmPackageArchitecture) ? this.RpmPackageArchitecture : GetPackageArchitecture(this.RuntimeIdentifier),
                        this.Release,
                        this.CreateUser,
                        this.UserName,
                        this.InstallService,
                        this.ServiceName,
                        this.Vendor,
                        this.Description,
                        this.Url,
                        this.Prefix,
                        this.PreInstallScript,
                        this.PostInstallScript,
                        this.PreRemoveScript,
                        this.PostRemoveScript,
                        dependencies,
                        null,
                        privateKey,
                        targetStream);
                }

            this.Log.LogMessage(MessageImportance.Normal, "Created RPM package '{0}' from folder '{1}'", this.RpmPath, this.PublishDir);
            return(true);
        }