Looking for recommendations
 

I'm curious to hear how all of you manage your third-party packages. I set up a build server about a year ago that builds all of SBo every week. I also have a few dozen custom packages that I build in-house and have a custom slackpkg+ repo for.

The problem I'm running into is that the sheer volume of dependencies for certain programs is becoming difficult to manage. I originally started with a custom script that would parse .dep files and install the necessary dependencies as other programs required them. That worked fine for things that only have a handful of dependencies, but things like openshot and vlc have a LOT of dependencies.

So, long story short, how do you all manage your dependencies to ensure you get everything you need for a given program?

I just use sqg that comes with sbopkg if I come across a program that have a lot deps.

I have a build server running only slackrepo and building from my own custom (private) GitLab repo.

slackrepo resolves all the dependencies for me.

In my GitLab repo I have over 450 SlackBuilds (for each 14.2 and current) and is probably ~95% my own SlackBuilds. Yes there is a ton of overlap between what I have and what is on SBo, but I like a little more control of how things get built and the dependencies.

My 14.2 branch has pretty much slowed down to a crawl because of dependency version requirements but my current branch is chugging right along.

I keep up with updates mostly via my feed reader (thanks Github for providing rss feeds) and watching the SBo changelog, along with Ponce's repo.

Yep, basically the Daedra approach is what I am using. Mostly I run up and down dependency trees when installing python programs. I don't like the way that with every platform one needs to use its own install-method, pip for python that is. So, yes I make slackbuilds for each of them and keep them in their own tree (dependencies with main program) and when the main stuff needs upgrading I check whether dependencies need to be done as well.

Anyway, a good idea to turn this into a github repo (another new thing to explore...)...

If you are using slackrepo to build everything, there is an option in there to enable slapt-get support. slapt-get is like slackpkg+, but it will support dependencies of packages, which will allow you to install all required dependencies for an application.

To enable it, you'd make sure FOR_SLAPTGET=1 is in your /etc/slackrepo/slackrepo_SBo.conf

For myself I wrote my own package builder (Afterpkg). It figures out dependencies, but then so do many other package management tools. One of my requirements was to use all 8 cores on my Ryzen regardless of whether the build itself supports that (e.g. Google golang doesn't), so it calculates which parts of the dependency tree can be parallelised and feeds them to the build engines in (hopefully) the appropriate order. I also wanted to do the builds on a VM, without having to maintain either the Afterpkg script *or* the slackbuilds repo on the VM itself, so all the build commands can be executed remotely via ssh.

I have a fair way to go. At the moment I'm in the process of automating the account creation, just putting the final touches to my parsable version of the slackbuilds uid_gid file: https://github.com/bifferos/afterpkg...er/uid_gid.txt. Sometimes that's required for the build, sometimes it's just required to run the package.

Ditto.
sqg was a game changer for me.

I used sqg for the entire slackbuilds repo. I then configured sbopkg to stick packages in /home/packages/SBo instead of /tmp. When I want to build something, I do it on my desktop machine. Then my other machines can pull packages using sftp and install them since all of my Slackware machines are amd64. Haven't had a problem with this setup yet.

For source builds (SBo), sbotools (handles deps for install and remove too if there's redundant packages laying around, supports -current, nice zsh completions).

Thanks for the prompt feedback everyone! I should note that my issue isn't with building the source code, I've been using slackrepo to manage that. It's ensuring that when I install things like virt-manager, or qemu, that all the dependencies get installed as well. I had also considered using tagfiles but the documentation I've found online has been sparse on that topic.

bassmadrigal, I hadn't really given any though into slapt-get; I'll have to look into that.

Last I checked, slackrepo handles installing dependencies (and also the options mentioned, sbotools/sbopkg+sqg), no?

slackrepo doesn't normally install the packages it generates (although, it will temporarily install them in an overlay chroot if they're dependencies for other packages that are being built -- when that package is then built, the chroot is destroyed, leaving a clean build system for the next package). It is designed to create a repo that other machines can then use to download and install packages from.

IIRC, there is an option that can build the packages outside of the chroot, but then packages in the repo can pick up unwanted/unexpected dependencies and could cause breakage on other systems.

Yeah it has the --install option. But from my experience, slackrepo seems pretty heavy duty for someone just wanting to install stuff (great for packaging etc though).