TIP Dealing with masked packages

From Gentoo Linux Wiki

[edit] Introduction

This article discusses how to deal with masked packages. For information on why packages are masked and the official methods of dealing with them, please see the Gentoo Handbook: Working With Portage: Mixing Software Branches.

[edit] Examples of Masked Packages

First, masked by keyword as a testing/unstable package: note the "(masked by: ~keyword)"

 # emerge gnome-extra/gdesklets-core

  '''Calculating dependencies'''   
  !!! all ebuilds that could satisfy "gnome-extra/gdesklets-core" have been masked.
  !!! possible candidates are:
  - gnome-extra/gdesklets-core-0.26 (masked by: ~keyword)
  - gnome-extra/gdesklets-core-0.26.1 (masked by: ~keyword)
  !!! Error calculating dependencies. Please correct.

Second, a Hard masked package: note the: "(masked by: package.mask)"

# emerge -pv filewatcher

These are the packages that I would merge, in order:

Calculating dependencies   
!!! All ebuilds that could satisfy "filewatcher" have been masked.
!!! One of the following masked packages is required to complete your request:
- app-admin/filewatcher-2.4.0 (masked by: package.mask)
# Elfyn McBratney <beu@gentoo.org> (28 Apr 2005)
# Masked for testing.

[edit] But you want to install the package anyway...

[edit] Masked by keyword

The new method is:

echo "gnome-extra/gdesklets-core" >> /etc/portage/package.keywords

or

echo "=gnome-extra/gdesklets-core-2.10.9" >> /etc/portage/package.keywords

if you want to unmask this specific version.

NOTE: You do not need to specify the architecture in package.keywords UNLESS you want to use an architecture which is different from your current one; this is not recommended.

If emerge says that the package was masked by "~* keyword", you'll need to take it literally and use, for instance:

echo "~gnome-extra/gdesklets-core-2.10.9 ~*" >> /etc/portage/package.keywords

Or if you using crossdev for build packages for multiple architectures.

echo "~gnome-extra/gdesklets-core-2.10.9 ~*" >> /etc/portage/package.keywords/cross-i686-pc-linux-gnu

OSB: i686-pc-linux-gnu in cross-i686-pc-linux-gnu name must change for each architecture.

Now, after performing either of the echoes above, emerge the file using the following:

emerge =gnome-extra/gdesklets-core-2.10.9

More info on this file provided here.

flagedit gnome-extra/gdesklets-core -- +~x86

emerge -pv kuroo

[edit] Invalid method (DO NOT USE)

ACCEPT_KEYWORDS="~x86" emerge gnome-extra/gdesklets-core

This is invalid and should not be used. Read this post on why ACCEPT_KEYWORDS isn't a good solution.... basically it's because emerge -u world will try to downgrade packages installed with ACCEPT_KEYWORDS, and can cause potentially fatal changes and cripple your system. The -U flag (upgrade only) is also deprecated for a very good reason - if package is broken, portage should downgrade it, -U disallows that behavior.

[edit] Masked by missing keyword

This is common if you are attempting to install the application when it has not been tested on your architecture.

If you have a CVS package marked has 9999 you can do the following: echo "media-gfx/retina **" >> /etc/portage/package.keywords

Bear in mind that if you install onto untested architecture for that application, it may not work.

[edit] Hard Masked

Hard Masked packages are unmasked by adding them to /etc/portage/package.unmask. The syntax for this file, however, slightly differs from package.keywords:

echo "=app-admin/filewatcher-2.4.0" >> /etc/portage/package.unmask

This would unmask version 2.4.0 of app-admin/filewatcher. If you want to unmask every version of a package, just specify its name like so:

echo "app-admin/filewatcher" >> /etc/portage/package.unmask

Of course, it is also possible to use the < and > operators like in package.keywords.

Note, that a package which has been hard masked is usually marked as unstable as well. You probably have to add the package to both package.unmask and package.keywords.

[edit] Manually Hard Masking

Rarely, you will need to prevent the installation of a package. This might be the case, for example, when a bug in the ebuild script causes it to fail to compile on your system, thus preventing commands like emerge --update --deep world to function properly.

You can skip the ebuild of the offending package by adding its name to /etc/portage/package.mask like this:

echo "=sys-apps/file-4.17-r1" >> /etc/portage/package.mask

The syntax for this file is the same as package.unmask, described above.

[edit] Easy editing of /etc/portage/package.keywords

[edit] flagedit

1. Install: emerge flagedit
2. Usage: flagedit <atom> -- +<keyword>, for example flagedit dev-util/libconf -- +~x86

[edit] User submitted scripts for unmasking packages

[edit] gimme

Here is a convenient script for emerging ~arch keyworded packages.

#!/bin/bash

############### gimme version 0.5.4 ################
# Script to add package names to package.keywords. #
# Originally by Tekmanx, re-written by Hackeron    #
# re-re-written by Gherald and edited by D. Watzke #
####################################################

source /sbin/functions.sh

 [[ $EUID != 0 ]]  && {
	eerror "You are not root!"
	exit 1
}

 [[ -z "$1" ]]  && {
	eerror "Please specify a package name (eg. gimme <package-name>)"
	exit 1
}

 [[ -d /etc/portage ]]  || mkdir -p /etc/portage

# Get fully-qualified ebuild name
FQN=$(ACCEPT_KEYWORDS="~x86" emerge -p $1 | grep "$1" | grep 'ebuild ' | tail -n2 | \
head -n1 | sed -e 's/\[ebuild.......\]\ //' -e 's/\[[[:digit:]].*\]//' -e 's/-[[:digit:]].*$//')

# We think there is either none or more than one package matching $1
# so we let the user deal with it
 [[ -z "$FQN" ]]  && emerge $@ -a; exit

if grep -q "^ *[\>\<=]*$FQN *" /etc/portage/package.keywords; then
	ewarn "/etc/portage/package.keywords already contains \"$EXISTING\""
	emerge $@ -a; exit
else
	einfo "Adding $FQN to package.keywords and emerging in 5 seconds."; sleep 5
	echo $FQN >> /etc/portage/package.keywords
	emerge $@ -a
fi

Save this to a file named "gimme" in /usr/bin/ and do: chmod 755 /usr/bin/gimme Now you're ready to use the script. For example: gimme gdesklets-core

[edit] Script for /etc/portage/package.unmask

Here is a convenient script for unmasking packages that have been hard masked by /usr/portage/profiles/package.mask

#!/bin/bash
#
# This script will unmask any package masked by the actual profile.
#
# First we search for what is actually masked 
# in /usr/portage/profiles/package.mask then add a corresponding 
# line in /etc/portage/package.unmask
#
#
# Original by drax@sweon.net

source /sbin/functions.sh

[ "$UID" -ne "0" ] && eerror "You must be root to run this script." && exit
[ -z "$1" ] && eerror "Please state a package name (eg. unmask kde-base/kode)" && exit
[ ! -d /etc/portage ] && einfo "Creating /etc/portage directory" && mkdir /etc/portage

if [ "$(grep "$1"-[0-9] /etc/portage/package.unmask 2>/dev/null)" ]; then
    ewarn "$1 already exists in package.unmask"
else
    PKG_LINE="$(grep "$1"-[0-9] /usr/portage/profiles/package.mask 2>/dev/null)"
    if [ ! $PKG_LINE ]; then
	PKG_LINE="$(grep "$1" /usr/portage/profiles/package.mask 2>/dev/null)"
    fi
    if [ ! $PKG_LINE ]; then
      ewarn "Could not find $1 in /usr/portage/profiles/package.mask" && exit 1
    else
      ebegin "Adding $1 to package.unmask"
      echo $PKG_LINE >> /etc/portage/package.unmask
      eend $?
    fi
fi

Again, put the file "unmask" in /usr/local/bin and do:

chmod 755 /usr/local/bin/unmask

Now you're ready to use the script... for instance:

unmask kde-base/kode # this version of unmask requires the full package name, including app-category/

You can also combine it with gimme, e.g.:

unmask kde-base/kode && gimme kode

Have fun. :)

[edit] Unmasking large groups of related packages

As of Portage 2.1, many of the /etc/portage/package.* files can now be directories instead. The files in the directory will be automatically concatenated by Portage. This is especially useful for modular X, which has almost 300 packages that need unmasking. Thus you can copy the modular X unmasking list to /etc/portage/package.keywords/xorg (and possibly /etc/portage/package.unmask/xorg) instead of /etc/portage/package.keywords, making the file FAR easier to manage.

[edit] Script for unmasking all dependencies

#!/bin/bash
#
# This script will unmask any package masked by specified keyword
#
# It is using flagedit to remove keyword
# Usage:  /bin/gimme-everything "=gnome-2.14.2" "+~amd64"
# Sorry that this is in one command line, but it was composed in one ;)
#
# author: mmazurek[at]wallix.com

while true; do
   if emerge "$1" | grep '!!! All ebuilds'; then
      emerge "$1" | grep '!!! All ebuilds' | while read line; do
         n=$(echo $line | sed -e "s/.*\"\(.*\)\".*/\\1/");
         flagedit "$n" -- "$2";
      done;
   else
      break;
   fi;
done

[edit] Script for unmasking all dependencies (2)

This is another "unmask all dependencies" script, which does not need flagedit.

#!/usr/bin/perl -w
use strict;

sub emerge {
        my $package = shift;
        $_ = `emerge -pv "${package}" 2>&1`;

        if(m/^- (\S+) \(masked by:.*package.mask/mi) {
                print "Unmasking ${1} in package.unmask\n";
                print UNMASK "=${1}\n";
                return 1;
        }
        if(m/^- (\S+) \(masked by:.*\s+(\S+)\s+keyword/mi) {
                print "Unmasking ${1} in package.keywords\n";
                if ($2 eq "missing") {
                        print KEYWORDS "=${1} ** ~* *\n"
                } else {
                        print KEYWORDS "=${1} ${2}\n";
                }
                return 1;
        }
        if(m/^!!! masked or don't exist:\n(\S+)/mi) {
                while(emerge($1) != 0){}
                return 1;
        }
        return 0;
}

open(UNMASK, ">>/etc/portage/package.unmask");
open(KEYWORDS, ">>/etc/portage/package.keywords");
our $package = $ARGV[0];
$package =~ s/"/\\"/g;
while(emerge($package) != 0){}
print "Done\n";
close(UNMASK);
close(KEYWORDS);

Usage:

unmask ">media-video/mplayer-1.0_rc1"