[sabayon-buildpackages] typo fix

Allow virtual dependency pruning to be controlled by env var

Makefile

@@ -25,5 +25,4 @@ install:
 	install -m 0755 builder $(DESTDIR)/$(USBINDIR)/
 
 	install -d $(DESTDIR)/$(UBINDIR)
-	install -m 0755 sabayon-buildpackages $(DESTDIR)/$(UBINDIR)/
-	install -m 0755 sabayon-createrepo $(DESTDIR)/$(UBINDIR)/
+	install -m 0755 sabayon-* $(DESTDIR)/$(UBINDIR)/

README.md

@@ -0,0 +1,117 @@
+# Sabayon devkit
+
+The *Sabayon devkit* is a set of scripts that aims to help developers in various tasks.
+
+You can install it in sabayon with:
+
+`
+sudo equo i sabayon-devkit
+`
+
+## Prerequisites
+
+* docker installed in the machine (`sudo equo i docker`), and the daemon started (`sudo systemctl start docker`)
+* if you don't want to run that as root, the user where are you running the script must be in the docker group (`sudo gpasswd -a $USER docker`)
+
+Packages can be built in a clean environment with docker by running `sabayon-buildpackages`.
+
+*`sabayon-buildpackages` and ``sabayon-createrepo are just a script wrapper around the development docker container.*
+
+## Define your workspace
+
+Create a directory to represent your project workspace.
+
+
+
+    cd $HOME
+    mkdir myproject
+    cd myproject
+
+
+if you plan to make packages from your own ebuilds, and you don't have an overlay published in layman, you can create the `local_overlay` directory and put your overlay tree inside it.
+
+
+
+    me@box:myproject/$ mkdir local_overlay
+
+
+`myproject/local_overlay` is read from the docker container and mounted inside it as the local overlay available in the machine.
+
+If you want, you can define the workspace directory with the variable environment `SAB_WORKSPACE`
+
+`SAB_WORKSPACE=/whatever sabayon-createrepo`
+
+
+## Folder structure
+
+This is the folder structure of your workspace by default, but you can tweak part of it to your tastes with Environment variables:
+
+`
+
+    myproject/
+    myproject/portage_artifacts/
+    myproject/entropy_artifacts/
+    myproject/local_overlay/
+    myproject/specs/
+`
+
+* myproject/portage\_artifacts/ -- Created when `sabayon-buildpackages` is started. It contains the portage artifacts, they will be consumed in the next steps
+* myproject/entropy\_artifacts/ -- Created when `sabayon-createrepo` is started. It contains the entropy repository files.
+* myproject/local_overlay/ -- is the location of your personal overlay (if necessary)
+* myproject/specs -- Create it to customize the building process. It can contain custom files for make.conf, uses, envs, masks, unmasks and keywords for package compilation options
+
+the `specs` folder is structured like this and it's merely optional.
+
+as long as you create those files they are used:
+
+- custom.unmask: that's the place for custom unmasks
+- custom.mask:  contain your custom masks
+- custom.use:  contain your custom use flags
+- custom.env:  contain your custom env specifications
+- custom.keywords: contain your custom keywords
+- make.conf:  it will replace the make.conf on the container with yours.
+
+you can override the Architecture folder in which files are placed specifying in the *SAB_ARCH* environment variable. Default is "intel" (can be *armarch* as for now)
+
+**Note: the portage_artifacts can also contain tbz2 files generated with other methods, if you already have your desired packages already compiled, you can just use `sabayon-createrepo`**
+
+# Building package in a clean environment
+
+`sabayon-buildpackages` accepts the same arguments as the builder:
+
+
+    sabayon-buildpackages app-text/tree
+    sabayon-buildpackages plasma-meta --layman kde
+    DOCKER_PULL_IMAGE=1 sabayon-buildpackages app-foo/foobar --equo foo-misc/foobar --layman foo --layman bar foo
+
+
+* --layman foobar -- tells the script to add the "foobar" overlay from layman
+* --equo foo-misc/foobar -- tells the script to install "foo-misc/foobar" before compiling
+
+ Environment variables:
+- DOCKER_PULL_IMAGE -- tells the script to update the docker image before compiling, enable it with 1, disable with 0
+- OUTPUT_DIR -- optional, default to "portage_artifacts" in your current working directory, it is the path where emerge generated tbz2 are stored (absolute path)
+- LOCAL_OVERLAY -- optional, you can specify the path to your local overlay (absolute path)
+ The arguments are the packages that you want compile, they can be also in the complete form *e.g. =foo-bar/misc-1.2*
+
+
+# Create Sabayon repository from \*.tbz2 in a clean environment
+
+You can create Sabayon repositories from packages built with emerge in a clean environment with docker by running `sabayon-createrepo`.
+
+The script will use a docker container to inject packages from  *portage_artifacts/*  in your project folder, the output will be available in *entropy_artifacts/*.
+
+Example:
+
+    sabayon-createrepo
+
+    REPOSITORY_NAME=mytest REPOSITORY_DESCRIPTION="My Wonderful Repository" sabayon-createrepo
+
+* REPOSITORY_NAME -- optional, is your repository name id
+* REPOSITORY_DESCRIPTION -- optional, is your repository description
+* PORTAGE_ARTIFACTS -- optional if you use the tools in the same dir, you can specify where portage artifacts (\*.tbz2 files) are (absolute path required)
+* OUTPUT_DIR -- optional, you can specify where the entropy repository will be stored
+
+You can also put your .tbz2 file externally built inside `entropy_artifacts/` in your workspace folder (you can create it if not already present)  and run `sabayon-createrepo` to generate a repository from them.
+
+In both `sabayon-createrepo` and `sabayon-buildpackages` you can override the docker image used with the environment variable `DOCKER_IMAGE`.

builder

@@ -1,43 +1,92 @@
 #!/usr/bin/env perl
 
 use Getopt::Long;
+use v5.10;
+no feature "say";
 
 my $profile           = $ENV{BUILDER_PROFILE}   // 3;
 my $jobs              = $ENV{BUILDER_JOBS}      // 1;
 my $use_equo          = $ENV{USE_EQUO}          // 1;
 my $preserved_rebuild = $ENV{PRESERVED_REBUILD} // 0;
 my $emerge_defaults_args = $ENV{EMERGE_DEFAULTS_ARGS}
-  // "--accept-properties=-interactive --verbose --oneshot --nospinner --quiet-build=y --complete-graph --buildpkg";
+  // "--accept-properties=-interactive --verbose --oneshot --complete-graph --buildpkg";
 $ENV{FEATURES} = $ENV{FEATURES}
   // "parallel-fetch protect-owned compressdebug splitdebug -userpriv";
 
 my $equo_install_atoms   = $ENV{EQUO_INSTALL_ATOMS}   // 1;
 my $equo_install_version = $ENV{EQUO_INSTALL_VERSION} // 0;
 my $equo_split_install   = $ENV{EQUO_SPLIT_INSTALL}   // 0;
+my $equo_mirrorsort      = $ENV{EQUO_MIRRORSORT}      // 1;
+my $entropy_repository   = $ENV{ENTROPY_REPOSITORY}
+  // "main";    # Can be weekly, main, testing
 my $artifacts_folder     = $ENV{ARTIFACTS_DIR};
+my $dep_scan_depth       = $ENV{DEPENDENCY_SCAN_DEPTH} // 2;
+my $skip_portage_sync    = $ENV{SKIP_PORTAGE_SYNC} // 0;
+my $emerge_split_install = $ENV{EMERGE_SPLIT_INSTALL} // 0;
+my $webrsync             = $ENV{WEBRSYNC} // 0;
+my $enman_repositories   = $ENV{ENMAN_REPOSITORIES};
+my $prune_virtuals       = $ENV{PRUNE_VIRTUALS} // 0;
+my $repository_name      = $ENV{REPOSITORY_NAME};
+my $enman_add_self       = $ENV{ENMAN_ADD_SELF} // 1;
+my $build_injected_args  = $ENV{BUILD_INJECTED_ARGS};
+my $equo_masks           = $ENV{EQUO_MASKS};
+my $equo_unmasks         = $ENV{EQUO_UNMASKS};
+
+my $make_conf = $ENV{MAKE_CONF};
 
 my @overlays;
+my $help = 0;
+GetOptions(
+    'layman|overlay:s{,}' => \@overlays,
+    'equo|install:s{,}'   => \@equo_install,
+    'equorm|remove:s{,}'  => \@equo_remove,
+    'help|?'              => \$help
+);
 
-GetOptions( 'layman|overlay:s{,}' => \@overlays, 'equo|install:s{,}' => \@equo_install  );
-
-if ( @ARGV == 0 ) {
-    help();
-    die();
-}
+help() if $help;
 
 $ENV{LC_ALL} = "en_US.UTF-8";    #here be dragons
 
 # A barely print replacement
 sub say { print join( "\n", @_ ) . "\n"; }
 
+sub safe_call {
+    my $cmd    = shift;
+    my $rt     = system($cmd);
+    my $return = $rt >> 8;
+    exit($return) if ($rt);
+}
+
 # Input: package, depth, and atom. Package: sys-fs/foobarfs, Depth: 1 (depth of the package tree) , Atom: 1/0 (enable disable atom output)
 sub package_deps {
     my $package = shift;
-    my $depth   = shift // 1;  # defaults to 1 level of depthness of the tree
+    my $depth   = shift // 1;    # defaults to 1 level of depthness of the tree
     my $atom    = shift // 0;
-    return
-      map { $_ =~ s/\[.*\]|\s//g; &atom($_) if $atom; $_ }
-      qx/equery -C -q g --depth=$depth $package/;    #depth=0 it's all
+
+# Since we expect this sub to be called multiple times with the same arguments, cache the results
+    state %cache;
+    $cache_key = "${package}:${depth}:${atom}";
+
+    if ( !exists $cache{$cache_key} ) {
+        @dependencies =
+          qx/equery -C -q g --depth=$depth $package/;    #depth=0 it's all
+        chomp @dependencies;
+
+# If an unversioned atom is given, equery returns results for all versions in the portage tree
+# leading to duplicates. The sanest thing to do is dedup the list. This gives the superset of all
+# possible dependencies, which isn't perfectly accurate but should be good enough. For completely
+# accurate results, pass in a versioned atom.
+        @dependencies = uniq(
+            sort
+              grep { $_ }
+              map { $_ =~ s/\[.*\]|\s//g; &atom($_) if $atom; $_ }
+              @dependencies
+        );
+
+        $cache{$cache_key} = \@dependencies;
+    }
+
+    return @{ $cache{$cache_key} };
 }
 
 #Input: nothing
@@ -54,26 +103,43 @@ sub available_packages {
 # Input: package (sys-fs/foobarfs)
 # Output: Array of packages to be installed, that aren't installed in a Sabayon machine
 sub calculate_missing {
-    my $package = shift;
-    my $depth = shift;
+    my $package            = shift;
+    my $depth              = shift;
+    my @Installed_Packages = @{ +shift };
+    my @Available_Packages = @{ +shift };
+    my $prune_virtuals     = shift;
 
     # Getting the package dependencies and the installed packages
-    say "[$package] Getting the package dependencies and the installed packages";
-    my @Packages = package_deps( $package, $depth, 1 );
-    my @Installed_Packages = qx/equo q --quiet list installed/;
-    chomp(@Installed_Packages);
-    say "[$package] Getting the package dependencies and the installed packages";
+    my @dependencies = package_deps( $package, $depth, 1 );
+
+    if ($prune_virtuals) {
+        say "[$package] Pruning dependencies of virtual packages";
+        my %install_dependencies = map { $_ => 1 } @dependencies;
+
+        # Look for any virtuals and remove its immediate dependencies to avoid
+        # installing multiple conflicting packages one by one
+        my @virtual_deps;
+        for my $dep (@dependencies) {
+            push( @virtual_deps, package_deps( $dep, 1, 1 ) )
+              if ( $dep =~ /^virtual\// );
+        }
+        for my $dep (@virtual_deps) {
+            $install_dependencies{$dep} = 0 if ( $dep !~ /^virtual\// );
+        }
+        @dependencies = grep { $install_dependencies{$_} } @dependencies;
+    }
 
     #taking only the 4th column of output as key of the hashmap
     my %installed_packs =
-      map { ( split( /\s/, $_ ) )[3] => 1 } @Installed_Packages;
-    my %available_packs = map { $_ => 1 } available_packages();
+      map { $_ => 1 } @Installed_Packages;
+    my %available_packs = map { $_ => 1 } @Available_Packages;
 
 # removing from packages the one that are already installed and keeping only the available in the entropy repositories
     my @to_install = grep( defined $available_packs{$_},
-        uniq( grep( !defined $installed_packs{$_}, @Packages ) ) );
-    @to_install=grep { length } @to_install;
-    say "[$package] packages that will be installed with equo: @to_install" if @to_install>0;
+        uniq( grep( !defined $installed_packs{$_}, @dependencies ) ) );
+    @to_install = grep { length } @to_install;
+    say "[$package] packages that will be installed with equo: @to_install"
+      if @to_install > 0;
 
     return @to_install;
 }
@@ -91,14 +157,15 @@ sub uniq {
 sub help {
     say "-> You should feed me with something", "", "Examples:", "",
       "\t$0 app-text/tree", "\t$0 plasma-meta --layman kde", "",
-      "\t$0 app-foo/foobar --equo foo-misc/foobar --equo net-foo/foobar --layman foo --layman bar foo",
+"\t$0 app-foo/foobar --equo foo-misc/foobar --equo net-foo/foobar --layman foo --layman bar foo",
       "**************************", "",
 "You can supply multiple overlays as well: $0 plasma-meta --layman kde plab",
+      "The documentation is available at https://github.com/Sabayon/devkit",
       "";
+    exit 0;
 }
 
-say
-"************* IF YOU WANT TO SUPPLY ADDITIONAL ARGS TO EMERGE, pass to docker EMERGE_DEFAULT_OPTS env with your options *************";
+say "****************************************************";
 
 if ( @overlays > 0 ) {
     say "Overlay(s) to add";
@@ -107,22 +174,19 @@ if ( @overlays > 0 ) {
     }
 }
 
-say "Installing:";
+say "[*] Installing:";
 
 say "\t* " . $_ for @ARGV;
 
-say "* Syncing stuff for you, if it's the first time, can take a while";
+say "[*] Syncing configurations files, Layman and Portage";
 
 # Syncronizing portage configuration and adding overlays
 system("echo 'en_US.UTF-8 UTF-8' > /etc/locale.gen");    #be sure about that.
-system(
-"cd /etc/portage/;git checkout master; git stash; git pull"
-);
+system("cd /etc/portage/;git checkout master; git stash; git pull");
 
-if (`uname -m` eq "x86_64\n"){
-  system(
-  "cd /etc/portage/;rm -rfv make.conf;ln -s make.conf.amd64 make.conf"
-  );
+if ( `uname -m` eq "x86_64\n" ) {
+    system(
+        "cd /etc/portage/;rm -rfv make.conf;ln -s make.conf.amd64 make.conf");
 }
 
 system("echo 'y' | layman -f -a $_") for @overlays;
@@ -154,48 +218,140 @@ auto-sync = no' > /etc/portage/repos.conf/local.conf
 
 system("mkdir -p /usr/portage/distfiles/git3-src");
 
-# sync portage and overlays
-system("layman -S;emerge --sync");
+unless ( $skip_portage_sync == 1 ) {
+
+    # sync portage and overlays
+    system("layman -S");
+    if ( $webrsync == 1 ) {
+        system("emerge-webrsync");
+    }
+    else {
+        system("emerge --sync");
+    }
+}
 
 # preparing for MOAR automation
 qx|eselect profile set $profile|;
 qx{ls /usr/portage/licenses -1 | xargs -0 > /etc/entropy/packages/license.accept}
   ;    #HAHA
-system("equo repo mirrorsort sabayonlinux.org;equo up && equo u")
-  if $use_equo;    # Better don't be behind
+
+if ( $use_equo && $entropy_repository eq "weekly" ) {
+    qx|equo repo disable sabayonlinux.org|;
+    qx|equo repo enable sabayon-weekly|;
+}
+elsif ( $use_equo && $entropy_repository eq "testing" ) {
+    qx|equo repo disable sabayon-weekly|;
+    qx|equo repo enable sabayonlinux.org|;
+    qx|equo repo enable sabayon-limbo|;
+}
+
+if ($use_equo) {
+    if ( $enman_repositories and $enman_repositories ne "" ) {
+        my @enman_toadd = split( / /, $enman_repositories );
+        safe_call("enman add $_") for @enman_toadd;
+    }
+
+    system("enman add $repository_name")
+      if ( $enman_add_self and $repository_name and $repository_name ne "" );
+    system("equo repo mirrorsort sabayonlinux.org") if $equo_mirrorsort;
+    system("equo up && equo u");
+}
+
+system("cp -rf $make_conf /etc/portage/make.conf") if $make_conf;
+
 qx|echo 'ACCEPT_LICENSE="*"' >> /etc/portage/make.conf|;    #just plain evil
 
 my @packages = @ARGV;
 
 if ($use_equo) {
     my @packages_deps;
+    my @Installed_Packages = qx/equo q list installed --quiet/;
+    my @Available_Packages = available_packages();
+    chomp(@Installed_Packages);
+
+    my %installed_packs =
+      map { $_ => 1 } @Installed_Packages;
+
+# Remove any already installed packages from the list of entropy packages to install in the build spec
+    @equo_install = grep { !exists $installed_packs{$_} } @equo_install;
+
     foreach my $p (@packages) {
-      say "[$p] Getting the package dependencies which aren't already installed on the system.. ''";
-        push( @packages_deps, calculate_missing( $p , 2) )
-          if $equo_install_atoms;
-        push( @packages_deps, package_deps( $p, 2, 0 ) )
+        say
+"[$p] Getting the package dependencies which aren't already installed on the system.. ";
+        push(
+            @packages_deps,
+            calculate_missing(
+                $p,                   $dep_scan_depth,
+                \@Installed_Packages, \@Available_Packages,
+                $prune_virtuals
+            )
+        ) if $equo_install_atoms;
+        push( @packages_deps, package_deps( $p, $dep_scan_depth, 0 ) )
           if $equo_install_version;
-      say "[$p] Done ''"
     }
     @packages_deps = grep { defined() and length() } @packages_deps;   #cleaning
-    say "", "[install] Installing missing dependencies with equo", @packages_deps, "";
+    say "", "[install] Those dependencies will be installed with equo :",
+      @packages_deps, "";
     if ($equo_split_install) {
-        system("equo i --bdeps $_") for (@packages_deps,@equo_install);
+        safe_call("equo i --bdeps $_")
+          for ( @packages_deps, @equo_install )
+          ; ## bail out here, if installs fails. emerge will compile a LOT of stuff
+        if ( @equo_remove > 0 ) {
+            system("equo rm --nodeps $_") for (@equo_remove);
+        }
     }
     else {
-        system("equo i --bdeps @packages_deps @equo_install");
+        safe_call("equo i --bdeps @packages_deps @equo_install")
+          if ( @packages_deps > 0 or @equo_install > 0 )
+          ; ## bail out here, if installs fails. emerge will compile a LOT of stuff
+        system("equo rm --nodeps @equo_remove") if ( @equo_remove > 0 );
     }
 }
 
-say "* Ready to compile, finger crossed";
+# best effort -B
+if ($equo_masks) {
+    system("equo mask $_") for ( split( / /, $equo_masks ) );
+}
 
-my $rt = system("emerge $emerge_defaults_args -j $jobs @packages");
+# best effort -B
+if ($equo_unmasks) {
+    system("equo unmask $_") for ( split( / /, $equo_unmasks ) );
+}
+
+say "*** Ready to compile, finger crossed ***";
+
+system("emerge --info")
+  ; #always give detailed information about the building environment, helpful to debug
+
+say "Devkit version:";
+system("equo s -vq app-misc/sabayon-devkit");
+
+my $rt;
+
+if ($emerge_split_install) {
+    for my $pack (@packages) {
+        my $tmp_rt = system("emerge $emerge_defaults_args -j $jobs $pack");
+
+#  $rt=$tmp_rt if ($? == -1 or $? & 127 or !$rt); # if one fails, the build should be considered failed!
+    }
+    $rt = 0;    #consider the build good anyway, like a "keep-going"
+}
+else {
+    $rt = system("emerge $emerge_defaults_args -j $jobs @packages");
+}
 
 my $return = $rt >> 8;
 
+# best effort -B
+if ($build_injected_args) {
+    system("emerge $emerge_defaults_args -j $jobs -B $_")
+      for ( split( / /, $build_injected_args ) );
+}
+
 if ($preserved_rebuild) {
 
     system("emerge -j $jobs --buildpkg \@preserved-rebuild");
+    system("revdep-rebuild");
 
 }
 

sabayon-brokenlibs

@@ -0,0 +1,26 @@
+#!/bin/bash
+
+PACKAGES=()
+bin=$1
+
+. /sbin/sabayondevkit-functions.sh
+
+[ -z "$bin" ] && die "No Arg given"
+
+# Getting linked libraries
+for i in $(ldd $1 | cut -d \( -f1 | cut -d \> -f2 | grep "/" | xargs echo)
+do
+  package=$(equo q belongs -q $i)
+  [ -z "$package" ] && die "borked: $i"
+  PACKAGES+=($package)
+done
+
+# Unique and ordered
+U_PACKAGES=$(echo "${PACKAGES[@]}" | tr ' ' '\n' | sort -u | tr '\n' ' ')
+
+if [ "${#PACKAGES}" -ne 0 ]; then
+	for i in ${U_PACKAGES[@]}
+	do
+	  echo " $i"
+	done
+fi

sabayon-buildpackages

@@ -1,7 +1,16 @@
 #!/bin/bash
 set -e
-ROOT="${ROOT:-$PWD}"
+SAB_WORKSPACE="${SAB_WORKSPACE:-$PWD}"
 DOCKER_IMAGE="${DOCKER_IMAGE:-sabayon/builder-amd64}"
+SAB_ARCH="${SAB_ARCH:-intel}"
+DOCKER_PULL_IMAGE="${DOCKER_PULL_IMAGE:-0}"
+MAKE_CONF="${MAKE_CONF:-$SAB_WORKSPACE/specs/make.conf}"
+OUTPUT_DIR="${OUTPUT_DIR:-$SAB_WORKSPACE/portage_artifacts/}"
+LOCAL_OVERLAY="${LOCAL_OVERLAY:-$SAB_WORKSPACE/local_overlay}"
+ENTROPY_REPOSITORY="${ENTROPY_REPOSITORY:-main}" # Can be weekly, main, testing
+DOCKER_OPTS="${DOCKER_OPTS:--ti --rm}"
+TEMPDIR=$(mktemp -d)
+
 . /sbin/sabayondevkit-functions.sh
 
 if [ $# -eq 0 ]
@@ -10,6 +19,71 @@ if [ $# -eq 0 ]
    exit 1
 fi
 
+docker_env=(-e "LC_ALL=en_US.UTF-8")
+docker_volumes=( -v "$OUTPUT_DIR:/usr/portage/packages" )
+
+[ -z "$PORTAGE_CACHE" ] || docker_volumes+=(-v "$PORTAGE_CACHE:/usr/portage")
+[ -z "$BUILDER_PROFILE" ] || docker_env+=(-e "BUILDER_PROFILE=$BUILDER_PROFILE")
+[ -z "$EMERGE_SPLIT_INSTALL" ] || docker_env+=(-e "EMERGE_SPLIT_INSTALL=$EMERGE_SPLIT_INSTALL")
+[ -z "$BUILDER_JOBS" ] || docker_env+=(-e "BUILDER_JOBS=$BUILDER_JOBS")
+[ -z "$USE_EQUO" ] || docker_env+=(-e "USE_EQUO=$USE_EQUO")
+[ -z "$PRESERVED_REBUILD" ] || docker_env+=(-e "PRESERVED_REBUILD=$PRESERVED_REBUILD")
+[ -z "$EQUO_INSTALL_ATOMS" ] || docker_env+=(-e "EQUO_INSTALL_ATOMS=$EQUO_INSTALL_ATOMS")
+[ -z "$DEPENDENCY_SCAN_DEPTH" ] || docker_env+=(-e "DEPENDENCY_SCAN_DEPTH=$DEPENDENCY_SCAN_DEPTH")
+[ -z "$FEATURES" ] || docker_env+=(-e "FEATURES=$FEATURES")
+[ -z "$EMERGE_DEFAULTS_ARGS" ] || docker_env+=(-e "EMERGE_DEFAULTS_ARGS=$EMERGE_DEFAULTS_ARGS")
+[ -z "$EQUO_INSTALL_VERSION" ] || docker_env+=(-e "EQUO_INSTALL_VERSION=$EQUO_INSTALL_VERSION")
+[ -z "$EQUO_SPLIT_INSTALL" ] || docker_env+=(-e "EQUO_SPLIT_INSTALL=$EQUO_SPLIT_INSTALL")
+[ -z "$ARTIFACTS_DIR" ] || docker_env+=(-e "ARTIFACTS_DIR=$ARTIFACTS_DIR")
+[ -z "$ENTROPY_REPOSITORY" ] || docker_env+=(-e "ENTROPY_REPOSITORY=$ENTROPY_REPOSITORY")
+[ -z "$SKIP_PORTAGE_SYNC" ] || docker_env+=(-e "SKIP_PORTAGE_SYNC=$SKIP_PORTAGE_SYNC")
+[ -z "$EQUO_MIRRORSORT" ] || docker_env+=(-e "EQUO_MIRRORSORT=$EQUO_MIRRORSORT")
+[ -z "$WEBRSYNC" ] || docker_env+=(-e "WEBRSYNC=$WEBRSYNC")
+[ -z "$ENMAN_REPOSITORIES" ] || docker_env+=(-e "ENMAN_REPOSITORIES=$ENMAN_REPOSITORIES")
+[ -z "$DISTFILES" ] || docker_volumes+=(-v "$DISTFILES:/usr/portage/distfiles")
+[ -z "$ENTROPY_DOWNLOADED_PACKAGES" ] || docker_volumes+=(-v "$ENTROPY_DOWNLOADED_PACKAGES:/var/lib/entropy/client/packages")
+[ -z "$DISTCC_HOSTS" ] || docker_env+=(-e "DISTCC_HOSTS=$DISTCC_HOSTS")
+[ -z "${PRUNE_VIRTUALS}" ] || docker_env+=(-e "PRUNE_VIRTUALS=$PRUNE_VIRTUALS")
+[ -z "$REPOSITORY_NAME" ] || docker_env+=(-e "REPOSITORY_NAME=$REPOSITORY_NAME")
+[ -z "$ENMAN_ADD_SELF" ] || docker_env+=(-e "ENMAN_ADD_SELF=$ENMAN_ADD_SELF")
+[ -z "$EQUO_MASKS" ] || docker_env+=(-e "EQUO_MASKS=$EQUO_MASKS")
+[ -z "$EQUO_UNMASKS" ] || docker_env+=(-e "EQUO_UNMASKS=$EQUO_UNMASKS")
+
+if [ -n "$REMOTE_OVERLAY" ]; then
+  git clone "$REMOTE_OVERLAY" "$TEMPDIR"
+  LOCAL_OVERLAY=$TEMPDIR
+fi
+
+function cleanup {
+	rm -rf "$TEMPDIR"
+}
+
+trap cleanup EXIT
+
+[ -d "$LOCAL_OVERLAY" ] && docker_volumes+=(-v "$LOCAL_OVERLAY:/usr/local/portage")
+
+if [ -e $MAKE_CONF ]; then
+  echo "You specified a make.conf. I hope you know what are you doing"
+  docker_volumes+=(-v "$MAKE_CONF:/etc/portage/make.conf.custom") # file make.conf.custom is in the docker container
+  docker_env+=(-e "MAKE_CONF=/etc/portage/make.conf.custom") # tell to the builder where is our custom make.conf
+fi
+
 check_docker_requirements
 
-docker run --rm -v "$ROOT"/portage_artifacts:/usr/portage/packages -ti $DOCKER_IMAGE $@
+[ $DOCKER_PULL_IMAGE -eq 1 ] && docker pull $DOCKER_IMAGE
+
+if [ -d "$SAB_WORKSPACE"/specs ]; then
+
+  [ -e "$SAB_WORKSPACE"/specs/custom.mask ] && docker_volumes+=(-v "$SAB_WORKSPACE/specs/custom.mask:/opt/sabayon-build/conf/$SAB_ARCH/portage/package.mask/99-custom.mask")
+  [ -e "$SAB_WORKSPACE"/specs/custom.unmask ] && docker_volumes+=(-v "$SAB_WORKSPACE/specs/custom.unmask:/opt/sabayon-build/conf/$SAB_ARCH/portage/package.unmask/99-custom.unmask")
+  [ -e "$SAB_WORKSPACE"/specs/custom.use ] && docker_volumes+=(-v "$SAB_WORKSPACE/specs/custom.use:/opt/sabayon-build/conf/$SAB_ARCH/portage/package.use/99-custom.use")
+  [ -e "$SAB_WORKSPACE"/specs/custom.env ] && docker_volumes+=(-v "$SAB_WORKSPACE/specs/custom.env:/opt/sabayon-build/conf/$SAB_ARCH/portage/package.env/99-custom.env")
+  [ -e "$SAB_WORKSPACE"/specs/custom.keywords ] && docker_volumes+=(-v "$SAB_WORKSPACE/specs/custom.keywords:/opt/sabayon-build/conf/$SAB_ARCH/portage/package.keywords/99-custom.keywords")
+
+fi
+
+echo "Spawning the package builder container for '$@'."
+echo ""
+#echo "docker run $DOCKER_OPTS ${docker_env[@]} ${docker_volumes[@]} $DOCKER_IMAGE $@"
+
+docker run $DOCKER_OPTS "${docker_env[@]}" "${docker_volumes[@]}" $DOCKER_IMAGE $@

sabayon-bz2brokenlibs

@@ -0,0 +1,26 @@
+#!/bin/bash
+
+. /sbin/sabayondevkit-functions.sh
+
+DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
+# the temp directory used, within $DIR
+WORK_DIR=`mktemp -d -p "$DIR"`
+
+# deletes the temp directory
+function cleanup {
+  rm -rf "$WORK_DIR"
+}
+
+# register the cleanup function to be called on the EXIT signal
+trap cleanup EXIT
+
+tbz=$1
+
+[ -z "$tbz" ] && die "No Arg given"
+
+tar xjf "$tbz" -C "$WORK_DIR"
+
+for file in $(find "$WORK_DIR" | xargs echo)
+do
+  [ -f "$file" ] && /usr/bin/sabayon-brokenlibs "$file"
+done

sabayon-createrepo

@@ -2,14 +2,41 @@
 set -e
 . /sbin/sabayondevkit-functions.sh
 
-ROOT="${ROOT:-$PWD}"
+SAB_WORKSPACE="${SAB_WORKSPACE:-$PWD}"
 entropysrv=$(mktemp)
 createrepo=$(mktemp)
 REPOSITORY_NAME="${REPOSITORY_NAME:-default}"
 REPOSITORY_DESCRIPTION="${REPOSITORY_DESCRIPTION:-My Sabayon repository}"
-DOCKER_IMAGE="${DOCKER_IMAGE:-sabayon/builder-amd64}"
+DOCKER_IMAGE="${DOCKER_IMAGE:-sabayon/eit-amd64}"
+PORTAGE_ARTIFACTS="${PORTAGE_ARTIFACTS:-$SAB_WORKSPACE/portage_artifacts}"
+OUTPUT_DIR="${OUTPUT_DIR:-$SAB_WORKSPACE/entropy_artifacts}"
+DOCKER_OPTS="${DOCKER_OPTS:--ti --rm}"
+
+args=("$@")
 EDITOR=cat
 
+docker_env=(-e "EDITOR=$EDITOR"
+            -e "REPOSITORY=$REPOSITORY_NAME"
+            -e "LC_ALL=en_US.UTF-8")
+
+docker_volumes=(
+            -v "$OUTPUT_DIR:/sabayon/artifacts"
+            -v "$createrepo:/sabayon/bin/create_repo.sh"
+            -v "$entropysrv:/etc/entropy/server.conf"
+)
+
+[ -z "$PUBKEY" ] || docker_volumes+=(-v "$PUBKEY:/etc/entropy/mykeys/key.pub")
+[ -z "$PRIVATEKEY" ] || docker_volumes+=(-v "$PRIVATEKEY:/etc/entropy/mykeys/private.key")
+
+
+if [ $# -eq 0 ]
+then
+ docker_volumes+=(-v "$PORTAGE_ARTIFACTS:/usr/portage/packages" )
+ else
+ echo "Packages directory: ${args[0]}"
+ docker_volumes+=(-v "${args[0]}:/usr/portage/packages" )
+fi
+
 check_docker_requirements
 
 echo "Repository: $REPOSITORY_NAME"
@@ -22,22 +49,29 @@ cat >$createrepo <<EOF
 set -e
 built_pkgs=\$(find /usr/portage/packages -name "*.tbz2" | xargs)
 repo="\${REPOSITORY:-default}"
-
-equo i entropy-server
 mkdir -p /sabayon/artifacts
 
-[[ -z "\${built_pkgs}" ]] && echo "ouch no pkgs found" && exit 2
+[[ -z "\${built_pkgs}" ]] && echo "ERROR: no tbz2s found" && exit 2
 
 if [ -d "/sabayon/artifacts/standard" ]; then
+  echo "=== Repository already exists, syncronizing ==="
   eit unlock \$repo || true
-  eit pull --quick $repo || true
+  eit pull --quick \$repo || true
   #eit sync \$repo
 else
+  echo "=== Repository is empty, intializing ==="
   echo "Yes" | eit init --quick \$repo
+  eit push --quick --force
 fi
 
+[ -f "/etc/entropy/mykeys/key.pub" ] && [ -f "/etc/entropy/mykeys/private.key" ] && { ! eit key status \$repo; } && \
+eit key import \$repo /etc/entropy/mykeys/private.key /etc/entropy/mykeys/key.pub && { eit key sign \$repo || true; } && { echo "=== Repository key imported successfully ==="; }
+
+echo "=== Injecting packages ==="
 echo "Yes" | eit inject \${built_pkgs} || { echo "ouch unable to inject" && exit 3; }
 echo "Yes Yes Yes" | eit commit --quick
+
+echo "=== Pushing built packages locally ==="
 eit push --quick --force
 
 EOF
@@ -68,11 +102,34 @@ default-repository = $REPOSITORY_NAME
 repository=$REPOSITORY_NAME|$REPOSITORY_DESCRIPTION|file:///sabayon/artifacts
 EOF
 
-docker run --rm --entrypoint /bin/bash -e REPOSITORY=$REPOSITORY_NAME -e EDITOR=cat -e LC_ALL=en_US.UTF-8 \
-		-v "$ROOT"/entropy_artifacts:/sabayon/artifacts \
-		-v $createrepo:/sabayon/bin/create_repo.sh \
-		-v $entropysrv:/etc/entropy/server.conf \
-		-v "$ROOT"/portage_artifacts:/usr/portage/packages \
-		-ti $DOCKER_IMAGE /sabayon/bin/create_repo.sh || true
+function cleanup {
+  rm -rf $createrepo
+  rm -rf $entropysrv
+}
+
+trap cleanup EXIT
+
+echo "docker $DOCKER_OPTS  ${docker_env[@]} ${docker_volumes[@]} $DOCKER_IMAGE /sabayon/bin/create_repo.sh"
+
+docker run  $DOCKER_OPTS --entrypoint /bin/bash "${docker_env[@]}" "${docker_volumes[@]}" $DOCKER_IMAGE /sabayon/bin/create_repo.sh || true
+
+if [ -d "$OUTPUT_DIR/standard" ]; then
+  echo "The Sabayon repository files are in $OUTPUT_DIR"
+  echo "Now you can upload its content where you want"
+
+  echo ""
+  echo "Here it is the repository file how will look like "
+  echo "(if you plan to upload it to a webserver, modify the URI accordingly)"
+  echo "
+  [$REPOSITORY_NAME]
+  desc = $REPOSITORY_DESCRIPTION
+  repo=file://$OUTPUT_DIR#bz2
+  enabled = true
+  pkg = file://$OUTPUT_DIR
+  "
+else
+  echo "Something failed :("
+fi
+
 rm -rf $createrepo
 rm -rf $entropysrv

sabayon-createrepo-cleanup

@@ -0,0 +1,94 @@
+#!/bin/bash
+set -e
+. /sbin/sabayondevkit-functions.sh
+
+SAB_WORKSPACE="${SAB_WORKSPACE:-$PWD}"
+entropysrv=$(mktemp)
+createrepo=$(mktemp)
+REPOSITORY_NAME="${REPOSITORY_NAME:-default}"
+REPOSITORY_DESCRIPTION="${REPOSITORY_DESCRIPTION:-My Sabayon repository}"
+DOCKER_IMAGE="${DOCKER_IMAGE:-sabayon/eit-amd64}"
+PORTAGE_ARTIFACTS="${PORTAGE_ARTIFACTS:-$SAB_WORKSPACE/portage_artifacts}"
+OUTPUT_DIR="${OUTPUT_DIR:-$SAB_WORKSPACE/entropy_artifacts}"
+DOCKER_OPTS="${DOCKER_OPTS:--ti --rm}"
+
+args=("$@")
+EDITOR=cat
+
+docker_env=(-e "EDITOR=$EDITOR"
+            -e "REPOSITORY=$REPOSITORY_NAME"
+            -e "LC_ALL=en_US.UTF-8")
+
+docker_volumes=(
+            -v "$OUTPUT_DIR:/sabayon/artifacts"
+            -v "$createrepo:/sabayon/bin/create_repo.sh"
+            -v "$entropysrv:/etc/entropy/server.conf"
+            -v "$PORTAGE_ARTIFACTS:/usr/portage/packages" )
+
+
+check_docker_requirements
+
+echo "Repository: $REPOSITORY_NAME"
+echo "Repository Description: $REPOSITORY_DESCRIPTION"
+echo "Remove: ${args[@]}"
+
+# Creating the building script on-the-fly
+cat >$createrepo <<EOF
+#!/bin/bash
+set -e
+repo="\${REPOSITORY:-default}"
+
+if [ -d "/sabayon/artifacts/standard" ]; then
+  eit unlock \$repo || true
+  eit pull --quick $repo || true
+  #eit sync \$repo
+else
+  echo "ouch no repository there" && exit 3;
+fi
+
+eit clean --quick || { echo "ouch unable to remove" && exit 3; }
+eit vacuum --quick || { echo "ouch unable to remove" && exit 3; }
+
+echo "Yes Yes Yes" | eit commit --quick
+eit push --quick --force
+
+EOF
+chmod +x $createrepo
+
+# Creating the entropy repository configuration on-the-fly
+cat >$entropysrv <<EOF
+# expiration-days = <internal value>
+community-mode = enable
+weak-package-files = disable
+database-format = bz2
+# sync-speed-limit =
+# server-basic-languages = en_US C
+# disabled-eapis = 1,2
+# expiration-based-scope = disable
+# nonfree-packages-directory-support = disable
+rss-feed = disable
+changelog = disable
+rss-name = packages.rss
+rss-base-url = http://packages.sabayon.org/?quicksearch=
+rss-website-url = http://www.sabayon.org/
+max-rss-entries = 10000
+# max-rss-light-entries = 100
+rss-light-name = updates.rss
+managing-editor =
+broken-reverse-deps = disable
+default-repository = $REPOSITORY_NAME
+repository=$REPOSITORY_NAME|$REPOSITORY_DESCRIPTION|file:///sabayon/artifacts
+EOF
+
+
+function cleanup {
+  rm -rf $createrepo
+  rm -rf $entropysrv
+}
+
+trap cleanup EXIT
+
+
+echo "docker run $DOCKER_OPTS --entrypoint /bin/bash ${docker_env[@]} ${docker_volumes[@]} $DOCKER_IMAGE /sabayon/bin/create_repo.sh"
+
+docker run $DOCKER_OPTS  --entrypoint /bin/bash "${docker_env[@]}" "${docker_volumes[@]}" $DOCKER_IMAGE /sabayon/bin/create_repo.sh || true

sabayon-createrepo-remove

@@ -0,0 +1,92 @@
+#!/bin/bash
+set -e
+. /sbin/sabayondevkit-functions.sh
+
+SAB_WORKSPACE="${SAB_WORKSPACE:-$PWD}"
+entropysrv=$(mktemp)
+createrepo=$(mktemp)
+REPOSITORY_NAME="${REPOSITORY_NAME:-default}"
+REPOSITORY_DESCRIPTION="${REPOSITORY_DESCRIPTION:-My Sabayon repository}"
+DOCKER_IMAGE="${DOCKER_IMAGE:-sabayon/eit-amd64}"
+PORTAGE_ARTIFACTS="${PORTAGE_ARTIFACTS:-$SAB_WORKSPACE/portage_artifacts}"
+OUTPUT_DIR="${OUTPUT_DIR:-$SAB_WORKSPACE/entropy_artifacts}"
+DOCKER_OPTS="${DOCKER_OPTS:--ti --rm}"
+
+args=("$@")
+EDITOR=cat
+
+docker_env=(-e "EDITOR=$EDITOR"
+            -e "REPOSITORY=$REPOSITORY_NAME"
+            -e "LC_ALL=en_US.UTF-8")
+
+docker_volumes=(
+            -v "$OUTPUT_DIR:/sabayon/artifacts"
+            -v "$createrepo:/sabayon/bin/create_repo.sh"
+            -v "$entropysrv:/etc/entropy/server.conf"
+            -v "$PORTAGE_ARTIFACTS:/usr/portage/packages" )
+
+
+check_docker_requirements
+
+echo "Repository: $REPOSITORY_NAME"
+echo "Repository Description: $REPOSITORY_DESCRIPTION"
+echo "Remove: ${args[@]}"
+
+# Creating the building script on-the-fly
+cat >$createrepo <<EOF
+#!/bin/bash
+set -e
+repo="\${REPOSITORY:-default}"
+
+if [ -d "/sabayon/artifacts/standard" ]; then
+  eit unlock \$repo || true
+  eit pull --quick $repo || true
+  #eit sync \$repo
+else
+  echo "ouch no repository there" && exit 3;
+fi
+
+echo "Yes" | eit rm --from \$repo ${args[@]} || { echo "ouch unable to remove" && exit 3; }
+echo "Yes Yes Yes" | eit commit --quick
+eit push --quick --force
+
+EOF
+chmod +x $createrepo
+
+# Creating the entropy repository configuration on-the-fly
+cat >$entropysrv <<EOF
+# expiration-days = <internal value>
+community-mode = enable
+weak-package-files = disable
+database-format = bz2
+# sync-speed-limit =
+# server-basic-languages = en_US C
+# disabled-eapis = 1,2
+# expiration-based-scope = disable
+# nonfree-packages-directory-support = disable
+rss-feed = disable
+changelog = disable
+rss-name = packages.rss
+rss-base-url = http://packages.sabayon.org/?quicksearch=
+rss-website-url = http://www.sabayon.org/
+max-rss-entries = 10000
+# max-rss-light-entries = 100
+rss-light-name = updates.rss
+managing-editor =
+broken-reverse-deps = disable
+default-repository = $REPOSITORY_NAME
+repository=$REPOSITORY_NAME|$REPOSITORY_DESCRIPTION|file:///sabayon/artifacts
+EOF
+
+
+function cleanup {
+  rm -rf $createrepo
+  rm -rf $entropysrv
+}
+
+trap cleanup EXIT
+
+
+echo "docker run $DOCKER_OPTS --entrypoint /bin/bash ${docker_env[@]} ${docker_volumes[@]} $DOCKER_IMAGE /sabayon/bin/create_repo.sh"
+
+docker run $DOCKER_OPTS  --entrypoint /bin/bash "${docker_env[@]}" "${docker_volumes[@]}" $DOCKER_IMAGE /sabayon/bin/create_repo.sh || true

sabayon-entropypreservedlibs

@@ -0,0 +1,34 @@
+#!/usr/bin/perl
+# Author: mudler@sabayonlinux.org, skullbocks@sabayonlinux.org
+
+use strict;
+use DBI;
+use feature 'say';
+
+my $arch = $ENV{ARCH} // "amd64";
+
+my $dbh = DBI->connect(
+    "dbi:SQLite:dbname=/var/lib/entropy/client/database/$arch/equo.db",
+    "", "", { RaiseError => 1 },
+) or die $DBI::errstr;
+my $to_build = {};
+
+my $sth = $dbh->prepare(
+"SELECT DISTINCT baseinfo.category, baseinfo.name, baseinfo.version FROM baseinfo JOIN needed_libs ON baseinfo.idpackage = needed_libs.idpackage JOIN preserved_libs ON needed_libs.soname = preserved_libs.library"
+);
+$sth->execute();
+
+my $row;
+while ( $row = $sth->fetchrow_arrayref() ) {
+    $to_build->{"@$row[0]/@$row[1]-@$row[2]"}++;
+}
+$sth->finish();
+
+my $to_install = join( " ", keys %{$to_build} );
+if ( $to_install ne "" ) {
+    say "Those packages seems to request libs no longer available: $to_install";
+}
+else {
+    say "No packages request outdated libs";
+}
+$dbh->disconnect();

sabayon-help-info

@@ -0,0 +1,6 @@
+#!/bin/bash
+
+sudo bash << EOF
+echo "Grabbing system informations, the url to share will happear in a minute"
+(echo 'lspci'; lspci; echo 'network'; ifconfig -a; echo 'drivers'; lsmod; find /lib/modules; echo 'kernel'; uname -a) | pastebunz
+EOF

sabayon-tbz2extract

@@ -0,0 +1,39 @@
+#!/usr/bin/python
+# mudler <mudler@sabayon.org>
+# Edit: create a truncated tbz2 with just data
+import os
+import sys
+from portage import xpak
+
+def usage():
+        sys.stderr.write("usage: %s <tbz2_file>\n" % os.path.basename(sys.argv[0]))
+
+def main():
+        if len(sys.argv) != 2:
+                usage()
+                return 1
+
+        input_file = sys.argv[1]
+
+        if not os.path.isfile(input_file):
+                usage()
+                return 1
+
+        output_file = input_file
+        if output_file.endswith('.tbz2'):
+                output_file = output_file[:-5]
+        output_file += '.truncated'
+
+        t = xpak.tbz2(input_file)
+        t.scan()
+        f = open(input_file, 'rb')
+        data = f.read(os.stat(input_file).st_size  - t.xpaksize)
+        f.close()
+
+        f = open(output_file, 'wb')
+        f.write(data)
+        f.close()
+        return 0
+
+if __name__ == '__main__':
+        sys.exit(main())

sabayon-tbz2truncate

@@ -0,0 +1,32 @@
+#!/usr/bin/python
+# mudler <mudler@sabayon.org>
+# Edit: truncate a tbz2 with just data
+import os
+import sys
+from portage import xpak
+
+def usage():
+        sys.stderr.write("usage: %s <tbz2_file>\n" % os.path.basename(sys.argv[0]))
+
+def main():
+        if len(sys.argv) != 2:
+                usage()
+                return 1
+
+        input_file = sys.argv[1]
+
+        if not os.path.isfile(input_file):
+                usage()
+                return 1
+
+        t = xpak.tbz2(input_file)
+        t.scan()
+        f = open(input_file, 'r+')
+        f.seek(-t.xpaksize, os.SEEK_END)
+        f.truncate()
+        f.close()
+
+        return 0
+
+if __name__ == '__main__':
+        sys.exit(main())

sabayon-xpakextract

@@ -0,0 +1,39 @@
+#!/usr/bin/python
+
+import os
+import sys
+from portage import xpak
+
+def usage():
+        sys.stderr.write("usage: %s <tbz2_file>\n" % os.path.basename(sys.argv[0]))
+
+def main():
+        if len(sys.argv) != 2:
+                usage()
+                return 1
+
+        input_file = sys.argv[1]
+
+        if not os.path.isfile(input_file):
+                usage()
+                return 1
+
+        output_file = input_file
+        if output_file.endswith('.tbz2'):
+                output_file = output_file[:-5]
+        output_file += '.xpak'
+
+        t = xpak.tbz2(input_file)
+        t.scan()
+        f = open(input_file, 'rb')
+        f.seek(-t.xpaksize, 2)
+        data = f.read()
+        f.close()
+
+        f = open(output_file, 'wb')
+        f.write(data)
+        f.close()
+        return 0
+
+if __name__ == '__main__':
+        sys.exit(main())

sabayondevkit-functions.sh

@@ -4,9 +4,11 @@ check_docker_requirements(){
   if [ "$(id -u)" != "0" ]; then
     groups | grep -q docker || echo "--> If you are not running the script as root, your user should be in the docker group to use it. (sudo gpasswd -a $USER docker)"
   fi
-  ps aux | grep -q '[d]ocker' || echo "--> Be sure to have the docker daemon running (sudo systemctl start docker)"
+  ps aux | grep -q '[d]ocker' || echo "--> Be sure to have the docker daemon running (sudo systemctl start docker) of configure it to run on boot (sudo systemctl enable docker). Trying to start it anyway" && sudo systemctl start docker
 }
 
+die() { echo "$@" 1>&2 ; exit 1; }
+
 build() {
 local SEARCH=$1
 local EMERGE_DEFAULT_ARGS=${2:---accept-properties=-interactive --verbose --oneshot --nospinner --quiet-build=y --quiet-fail --fail-clean=y --complete-graph --buildpkg}