sudo lafilefixer --justfixit

It won’t create the .la file, but it will fix the libtool references so nothing points to it so packages will compile fine.

emerge -pvu world

The new version lists the best version available for each package which can be updated using the --verbose flag. You can download the new version from here: search_for_updates-0.2.

$ sudo xclock
No protocol specified
Error: Can't open display: :0.0

The same error appeared even when I executed xclock after running sudo su.

Apperantly, by default the X server doesn’t allow anyone else besides you to open windows on the display. While it’s generally a good thing, it’s annoying if you’re trying to preform some GUI stuff as root. You can use the xauth utility to grant permissions to other users. For example:

$ xhost local:root
non-network local connections being added to access control list

Allows root user connecting from the local machine (like sudo) to access the X display for your user. You can see the current access list by simply typing xhost.

$ emerge -puv world

And then you usually select the packages you really want to update and emerge them. However this workflow has several downsides:

1. It’s slow. When portage checks for updates this way it fully resolves all the dependencies. This process is unnecessary, as in many cases you aren’t interested in updating all the packages, furthermore in their dependencies.
2. It may fail. When portage fails to resolve the dependencies, it will either complain or completely fail. If it complains, it isn’t really that bad, except for the time used for resolving the unanswered dependencies. Sometimes it fails completely (usually when masking is involved) and won’t display any of the available packages, hence leaving the user in the dark (except for some dependency error message).
3. It displays lot’s of output. Many times you’re not interesting in seeing the dependencies that will be updated if you emerge every package in the world file. It’s just confusing and distract you from the interesting updates for packages in the world file.

The following scripts tries to work around these problems. It works by querying the portage API for the best version available for each package in the world file. If that version isn’t installed it reports that there are updates waiting for that package. The script runs faster then emerge -pvu world and only displays the packages from the world file. If you find a package that you want to upgrade you can emerge it separately to see the required dependencies.

#! /usr/bin/env python
 
#   Copyright 2010 Guy Rutenberg
 
#   This program is free software: you can redistribute it and/or modify
#   it under the terms of the GNU General Public License as published by
#   the Free Software Foundation, either version 3 of the License, or
#   (at your option) any later version.
 
#   This program is distributed in the hope that it will be useful,
#   but WITHOUT ANY WARRANTY; without even the implied warranty of
#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#   GNU General Public License for more details.
 
#   You should have received a copy of the GNU General Public License
#   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 
import portage
import logging
import subprocess
from optparse import OptionParser
 
class MainApp:
    def __init__(self,args=None):
        usage = "Usage: %prog [options]"
        version = "0.1"
        parser = OptionParser(usage,version=version)
        parser.add_option("","--kde", dest="kde",default=False,
                          action="store_true",
                          help="Post a notification with the number of update")
        parser.add_option("-q","--quiet", dest="quiet",default=False,
                          action="store_true",
                          help="Make as little output as possible")
        (self.options, self.args) = parser.parse_args(args=args)
 
    def run(self):
        self.updatable = set()
        for atom in self.get_world_entries():
            if self.get_best_version(atom) not in self.get_installed_versions(atom):
                self.updatable.add(atom)
                print atom
        if self.options.kde:
            self.notify_kde()
        if not self.options.quiet:
            print "Total:",len(self.updatable)
 
    def notify_kde(self):
        if len(self.updatable):
            text = "There are %i updates" % len(self.updatable)
        else:
            text = "There are no updates"
        subprocess.call(["kdialog", "--passivepopup", text, "--title", "Portage Updates"])
 
    @staticmethod
    def get_world_entries():
        """
        parses the world file and returns a set of all the atoms
        """
        f = open("/"+portage.WORLD_FILE, "r")
        atoms = set()
        for line in f.readlines():
            atom = line[:-1]
            if portage.isvalidatom(line[:-1]):
                atoms.add(atom)
        f.close()
        return atoms
 
    @staticmethod
    def get_installed_versions(atom):
        return portage.db['/']['vartree'].dbapi.match(atom)
 
    @staticmethod
    def get_best_version(atom):
        """
        Returns the best available version taking into account masking and
        keywords
        """
        available = portage.db['/']['porttree'].dbapi.match(atom)
        return portage.best(available)
 
 
if __name__ == "__main__":
    app = MainApp()
    app.run()
 
 
# vim: filetype=python ai ts=5 sts=4 et sw=4

sudo emerge -avu1 $(qlist -IvC /qt- | grep 4. | sed s/-4.*//)

This will allow Gentoo to solve the dependencies by uninstalling the old versions, unlike if you only try to upgrade a single package like x11-libs/qt-core

emerge -avu world

but I encountered some nasty conflicts that I didn’t have time, nor will, to resolve at that time. So I’ve looked for a different solution. To my rescue came qlist for the great app-portage/portage-utils package. This package provides a set of very fast utilities to query portage. I’ve used qlist to list all of my installed packages, grep‘ed the list and piped the result as arguments to emerge using xargs.

 qlist -I --nocolor | grep kde | xargs emerge -pvu1

Take a look at the package list that will be merged. If everything looks fine, then do the actual merging.

 qlist -I --nocolor | grep kde | xargs sudo emerge -vu1

The --nocolor is important, or else emerge will complain about the benign looking atoms such as dev-util/kdevelop because there are invisible terminal formating characters around them.

In this post I’ll try to walk you through the necessary steps to install phpMyAdmin with Lighttpd in Gentoo.

Installing Lighttpd and PHP

Before installing Lighttpd and PHP you’ll need to enable some USE flags. For Lighttpd you’ll need to at least enable the php and fastcgi USE flags. For PHP enable the cgi, crypt, ctype, pcre, session, unicode. The first one is required for working with Lighttpd, while the others are required for phpMyAdmin.

See the handbook for information about enabling USE flags.

Now install the packages

emerge -av lighttpd php

After installation is complete, start the Lighttpd process

/etc/init.d/lighttpd start

and you should have a working Lighttpd server with PHP support.

Installing phpMyAdmin

phpMyAdmin depends on a package called webapp-config. While usually we let Portage take care of dependencies, this time we’ll have to install webapp-config manually before we install phpMyAdmin, so we can change its configuration for suit Lighttpd.

emerge -av --oneshot webapp-config

After installation is done edit using your favourite editor the /etc/vhosts/webapp-config and change the line:

vhost_server="apache"

to

vhost_server="lighttpd"

Now we are ready to install phpMyAdmin.

emerge -av phpmyadmin

After installation is complete, you’ll need to create a phpMyAdmin configuration file

cp /var/www/localhost/htdocs/phpmyadmin/config.sample.inc.php /var/www/localhost/htdocs/phpmyadmin/config.inc.php

Now open the newly created configuration file and edit the line with the blowfish_secret (at the top of the file) as explained in it. An easy way to generate the password would be to use spass.

Now if you use the default Lighttpd configurations you’re done. You can access the phpMyAdmin via http://localhost/phpmyadmin. If however you’ve changed the document root, there is one more step for you. Enable the mod_alias module in /etc/lighttpd/lighttpd.conf and append to the file

alias.url += ("/phpmyadmin" => "/var/www/localhost/htdocs/phpmyadmin")

and don’t forget to restart the Lighttpd server after making the changes.

You should have by now everything installed and configured to work. If you have any further questions don’t hesitate to comment.