There's now a worker thread per Root that does all the work that can
take time. Node monitoring notifications received in the main thread are
just pushed into the worker's job queue, so the application looper
remains responsive.
* packagefs: Disable (comment out) node monitoring of the packages
directory.
* package daemon:
- When a packagefs volume is added load the respective packages
directory and get from the volume which of the packages are
activated.
- Add node monitoring for the packages directory and
activate/deactivate packages as packages are added/removed.
* Add PACKAGE_FS_OPERATION_GET_PACKAGE_INFOS which returns the node refs
of all packages activated.
* Add PACKAGE_FS_OPERATION_CHANGE_ACTIVATION to activate/deactivate
multiple packages.
* The package directory path specified when mounting must be interpreted
in the caller's I/O context. We did always interpret it in the
kernel's I/O context, so that a relative path or a path in a chroot
environment wouldn't work correctly. Now opening the directory is done
in PackageDomain::Init() where we can at least guess the path's
origin.
* We also normalize the path, though merely to get more conclusive debug
output, since after opening the directory the path isn't used for
anything else anymore.
* Make the "packages" mount parameter optional. If not specified, use
the "packages" folder at our mount point.
B_ALREADY_WIRED, which was erroneously passed for the area protection
parameter to map_backing_store(), has the value 7 which implies user
readable and writable. Hence the address ranges around 0xdeadbeef and
0xcccccccc could actually be read and written from anywhere.
The tree comparisons didn't allow for different Nodes having the same
attribute value. Therefore only the first node would be added and later
we would try to remove a node not actually in the tree, leading to a
crash.
packagefs seems to finally unmount cleanly, now.
* Volume::_RemovePackageLinksDirectory(): We don't want to call
_RemovePackageLinksNode(). Besides that the ID hash table has already
been emptied before and we would thus release a reference to the node
erroneously, the method doesn't do anything we want anyway. We don't
want any children to be removed, since we have unregistered the
volume's packages already (which removes the respective package link
directories); the remaining ones are from other volumes and not ours
to remove.
* PackageFSRoot: Release a reference to the package links directory in
the destructor. We create the directory in Init() after all and no one
else takes over ownership.
Since we publish shine-through directories directly to the VFS, we need
to acquire an additional reference, because we release a reference when
a node is put.
PackageLinkDirectory::NotifyDirectoryAdded() first notified the listener
(Volume) about the directory itself, then about the links it contained.
Since Volume adds the nodes recursively, the latter were added twice,
resulting in a corrupted ID hash table.
* Make sure that the computed dependencies don't themselves depend on
the specified package.
* Print only the actual dependencies, not the specified package.
* Now it only gets a package (info) file and a single list of
repository directories, optionally with priority, and resolves the
package's dependencies. The more complex two resolving steps it did
before can just as well be done by haikuporter, and this way the
command is more flexible.
* Rename to resolve-dependencies.
* Some TODOs still remain.
This is a service command for haikuporter. It resolves the dependencies
for a package to be built and lists them, so that haikuporter can
prepare the build environment accordingly.
The implementation isn't quite finished yet. Currently the packages are
printed only with name and version, while it would probably be more
helpful to print the path of the package file. Also, the package itself
(respectively a dummy package) is printed as well.
* Reorganize things a bit:
- BSolver is now an abstract base class.
- A libsolv based implementation, LibsolvSolver, lives in a new
add-on, which is loaded lazily.
- Get rid of libpackage_solver. Save for LibsolvSolver everything
is moved to libpackage.
- This is a nicer solution for the cyclic dependency caused by
libsolv (libsolvext to be precise) using the package kit for
reading repositories and package files.
* Add a solver result data structure and and an accessor the solver.
* Add problem reporting support to the solver. There aren't data
structures for the problem solutions yet and support for selecting
solutions and re-solving is missing as well.
* BPackageVersion: Add respective constructor and SetTo().
* BPackageInfo: Add static ParseVersionString() utility method. It's
only there because the parser lives in the BPackageInfo
implementation.
* StandardErrorOutput.cpp no longer exists (respectively has been moved
to libpackage).
* Add hack to allow building more correctly on Haiku. We were using
the installed package kit headers, not the ones from the working
directory.
* The recently introduced {No,Standard}ErrorOutput.cpp were still
missing.
* Add hack to allow building more correctly on Haiku. We were using
the installed package kit headers, not the ones from the working
directory.
* The call to the dummy actions isn't needed
* The calls to Extract{Zip,Tar,HPKG}Archive1 couldn't work like that.
The directory has to be the main target, since ExtractArchive is
potentially invoked multiple times with different extracted file
targets and the Extract*Archive1 is only invoked the first time.
Tested only with the HPKG actions, but they others should work as
well.
* Move StandardErrorOutput to libpackage and into proper namespace to
avoid "package_repo" having to reuse the "package" source file.
* package_repo: Fix incorrect includes of "package.h".
Not functional (or tested) yet. The libsolv setup for a somewhat
simplified installation case should be more or less complete, though.
The solution conversion to to-be-created Haiku data structures and the
handling of problems is still missing, though.
