Changeset 1903 in ProjectBuilder

Timestamp:

Oct 8, 2014, 1:35:10 PM (10 years ago)

Author:

Bruno Cornec

Message:

• Add entries for osrepo for mageia/mandriva distros to allow setupve to work for these distributions without resorting to sbx2setupve
• pbkeep now managed in pb_temp_init to avoid removing the temps dir when debugging
• Add functions pb_ve_docker_get_image and pb_ve_get_type
• lots of interfaces changes to allow support of docker, including script names. May break other non docker features
• both newve and setupve work with docker now.
• manages public keys for urpmi distriutions
• Adds function pb_parallel_launchv. Now pb_launchv is single V

Location:

devel

Files:

• pb-modules/etc/pb.conf (modified) (2 diffs)
• pb-modules/etc/pb.conf.pod (modified) (1 diff)
• pb-modules/lib/ProjectBuilder/Base.pm (modified) (2 diffs)
• pb-modules/lib/ProjectBuilder/VE.pm (modified) (8 diffs)
• pb/bin/pb (modified) (39 diffs)

devel/pb-modules/etc/pb.conf

@@ -414 +414 @@
 # When using docker some specific conf items
 dockerregistry default = http://localhost:5000/pb
+#dockeropt default =
+# Some options to pass to the docker command such as IP conf when firewalled --bip=172.17.42.1/16
+# used in addition with shorewall with a masq file having "eth0 172.17.0.0/16"
 #dockerimage mageia-4-x86_64 = mageia-4-x86_64
 #dockertag pb = pb
@@ -701 +704 @@
 osrepo redhat-6.2 =
 osrepo rpm = ftp://ftp.project-builder.org/$pbos->{'name'}/$pbos->{'version'}/$pbos->{'arch'}/pb.repo
+osrepo mageia = ftp://ftp.project-builder.org/$pbos->{'name'}/$pbos->{'version'}/$pbos->{'arch'}/pb.addmedia
+osrepo mandriva = ftp://ftp.project-builder.org/$pbos->{'name'}/$pbos->{'version'}/$pbos->{'arch'}/pb.addmedia
 osrepo deb = ftp://ftp.project-builder.org/$pbos->{'name'}/$pbos->{'version'}/pb.sources.list
 

devel/pb-modules/etc/pb.conf.pod

@@ -111 +111 @@
  Example: delivery mondorescue = prod
 
+=item B<dockeropt>
+
+ Nature: Optional
+ Key: project (as defined in the -p option or PBPROJ environment variable)
+ Value: List of the options to call docker with
+ Conffile: project
+ Example: dockeropt default = --bip=172.16.42.1/16
+
 =item B<dockerregistry>
 

devel/pb-modules/lib/ProjectBuilder/Base.pm

@@ -425 +425 @@
 
 sub pb_temp_init {
+
+my $pbkeep = shift || 0;    # Do not keep temp files by default
 
 if (not defined $ENV{'TMPDIR'}) {
@@ -450 +452 @@
     pb_mkdir_p("$ENV{'TMPDIR'}/$template");
 } else {
-    if ($pbdebug > 1) {
+    if (($pbdebug > 1) || ($pbkeep == 1)) {
         $ENV{'PBTMP'} = tempdir( "pb.XXXXXXXXXX", DIR => $ENV{'TMPDIR'});
         pb_log(2,"DEBUG: Creating a non-volatile temporary directory ($ENV{'PBTMP'})\n");

devel/pb-modules/lib/ProjectBuilder/VE.pm

@@ -16 +16 @@
 use Carp 'confess';
 use English;
+use File::Basename;
 use ProjectBuilder::Version;
 use ProjectBuilder::Base;
@@ -31 +32 @@
  
 our @ISA = qw(Exporter);
-our @EXPORT = qw(pb_ve_launch pb_ve_snap);
+our @EXPORT = qw(pb_ve_launch pb_ve_snap pb_ve_get_type pb_ve_docker_repo pb_ve_docker_get_image);
 
 ($VERSION,$REVISION) = pb_version_init();
@@ -66 +67 @@
 sub pb_ve_launch {
 
-my $v = shift || undef;
-my $pbforce = shift || 0;       # By default do not rebuild VE
-my $locsnap = shift || 0;       # By default do not snap VE
-my $vetype = shift || undef;        # By default no image
-my $pbimage = shift || undef;       # By default no image
+my $v = shift;
+my $pbscript = shift;
+my $pbforce = shift;    
+my $pbstep= shift;          # Which step are we in (0: create, 1: setup, 2: build, 3: use)
+my $locsnap = shift;
+my $vetype = shift;
+my $pbimage = shift;
 
 my $dockerregistry = undef;
 my $docrepo = undef;            # By default no repository for docker available
 
+pb_log(2,"Entering pb_ve_launch at step $pbstep\n");
 # Get distro context
 my $pbos = pb_distro_get_context($v);
 
-# Get VE context
-if (not defined $vetype) {
-    my ($ptr) = pb_conf_get("vetype");
-    $vetype = $ptr->{$ENV{'PBPROJ'}};
-}
-confess "No vetype defined for $ENV{PBPROJ}" unless (defined $vetype);
-pb_log(1, "Using vetype $vetype for $ENV{PBPROJ}\n");
+$vetype = pb_ve_get_type($vetype);
 my ($vepath) = pb_conf_get("vepath");
 
@@ -114 +112 @@
     if ($EFFECTIVE_USER_ID != 0) {
         $sudocmd ="sudo ";
-    foreach my $proxy (qw/http_proxy ftp_proxy/) {
+        foreach my $proxy (qw/http_proxy ftp_proxy/) {
             if (defined $ENV{$proxy}) {
                 open(CMD,"sudo sh -c 'echo \$$proxy' |") or die "can't run sudo sh?: $!";
@@ -132 +130 @@
     if (((((defined $verebuild) && ($verebuild->{$ENV{'PBPROJ'}} =~ /true/i)) || ($pbforce == 1)) && ($vetype ne "docker"))
         # For docker we may have a reference image that we'll use
-        || (((not defined $pbimage) || ($pbimage eq "")) && ($vetype eq "docker"))) {
+        || (($vetype eq "docker") && ($pbstep == 0))) {
 
         my ($verpmtype,$vedebtype) = pb_conf_get("verpmtype","vedebtype");
@@ -275 +273 @@
         ((defined $vesnap->{$ENV{'PBPROJ'}}) && ($vesnap->{$ENV{'PBPROJ'}} =~ /true/i))) &&
         ($locsnap eq 1) &&
+        ($vetype ne "docker") &&
         (! -d "$root/$pbos->{'name'}/$pbos->{'version'}/$pbos->{'arch'}")) {
             my $cmd1 = pb_check_req("rm",0);
@@ -281 +280 @@
             pb_system("$sudocmd $cmd1 -rf $root/$pbos->{'name'}/$pbos->{'version'}/$pbos->{'arch'} ; $sudocmd $cmd2 -p $root/$pbos->{'name'}/$pbos->{'version'}/$pbos->{'arch'} ; $sudocmd $cmd3 xz  -C $root/$pbos->{'name'}/$pbos->{'version'}/$pbos->{'arch'} -f $root/$pbos->{'name'}-$pbos->{'version'}-$pbos->{'arch'}.tar.gz","Extracting snapshot of $pbos->{'name'}-$pbos->{'version'}-$pbos->{'arch'}.tar.gz under $root/$pbos->{'name'}/$pbos->{'version'}/$pbos->{'arch'}");
     }
-    
-    # Fix modes to allow access to the VE for pb user
-    my $command = pb_check_req("chmod",0);
-    pb_system("$sudocmd $command 755 $root/$pbos->{'name'} $root/$pbos->{'name'}/$pbos->{'version'} $root/$pbos->{'name'}/$pbos->{'version'}/$pbos->{'arch'}","Fixing permissions");
+
+    if ($vetype ne "docker") {
+        # Fix modes to allow access to the VE for pb user
+        my $command = pb_check_req("chmod",0);
+        pb_system("$sudocmd $command 755 $root/$pbos->{'name'} $root/$pbos->{'name'}/$pbos->{'version'} $root/$pbos->{'name'}/$pbos->{'version'}/$pbos->{'arch'}","Fixing permissions");
+    }
 
     # If docker, create the image and remove the now temp dir except if we had one already
-    if ($vetype eq "docker") {
-        if ((not defined $pbimage) || ($pbimage eq "")) {
-            # Snaphot the VE to serve as an input for docker
-            pb_ve_snap($pbos,$root);
-            # Create the docker image from the previous bootstrap
-            my $cmd1 = pb_check_req("docker",0);
-            $docrepo = pb_ve_docker_repo($dockerregistry->{$ENV{'PBPROJ'}});
-            # Need sudo to be able to create all files correctly
-            pb_system("$sudocmd $cmd1 import - $docrepo:$pbos->{'name'}-$pbos->{'version'}-$pbos->{'arch'} < $root/$pbos->{'name'}-$pbos->{'version'}-$pbos->{'arch'}.tar.gz");
-            pb_system("$cmd1 push $docrepo:$pbos->{'name'}-$pbos->{'version'}-$pbos->{'arch'}");
-        #} else {
-        }
+    if (($vetype eq "docker") && ($pbstep == 0)) {
+        $docrepo = pb_ve_docker_repo($dockerregistry->{$ENV{'PBPROJ'}});
+        my $cmd1 = pb_check_req("docker",0);
+        # step 0 : nothing at creation -> tag n-v-a (made below)
+
+        # Snaphot the VE to serve as an input for docker
+        pb_ve_snap($pbos,$root);
+        # Create the docker image from the previous bootstrap
+        # Need sudo to be able to create all files correctly
+        # TODO: check before that the image doesn't already exist in the docker registry
+        my $pbimage = "$docrepo:$pbos->{'name'}-$pbos->{'version'}-$pbos->{'arch'}";
+        pb_system("$sudocmd $cmd1 import - $pbimage < $root/$pbos->{'name'}-$pbos->{'version'}-$pbos->{'arch'}.tar.gz");
+        pb_system("$cmd1 push $pbimage");
     }
 
@@ -376 +378 @@
 }
 
+sub pb_ve_docker_get_image {
+
+my $pbimage = shift || undef;
+my $found = 0;
+
+die "Unable to handle an undef docker image" if (not defined $pbimage);
+
+# Check that this docker image exists
+my $cmd1 = pb_check_req("docker",0);
+open(CMD, "$cmd1 images |") || die "Unable to get docker image list";
+my ($repo, $tag, $id, $dummy);
+while (<CMD>) {
+    ($repo, $tag, $id, $dummy) = split(/\s+/,$_,4);
+    $found = $id if ("$repo:$tag" eq $pbimage);
+}
+close(CMD);
+return($found);
+}
+sub pb_ve_get_type {
+
+my $vetype = shift || undef;
+
+# Get VE context
+if (not defined $vetype) {
+    my ($ptr) = pb_conf_get("vetype");
+    $vetype = $ptr->{$ENV{'PBPROJ'}};
+}
+confess "No vetype defined for $ENV{PBPROJ}" unless (defined $vetype);
+pb_log(1, "Using vetype $vetype for $ENV{PBPROJ}\n");
+return($vetype);
+}
+
+
 =head1 WEB SITES
 

devel/pb/bin/pb

@@ -41 +41 @@
 
 # Global variables
-$Global::pb_stop_on_error = 0;  # False by default
-$Global::pb_show_sudo = 0;      # False by default
-
-my %opts;                   # CLI Options
-my $action;                 # action to realize
-my $test = "FALSE";         # Not used
-my $pbforce = 0;            # Force VE/VM rebuild
-my $pbsnap = 0;             # Do not use snapshot mode for VM/VE by default
-my $pbkeep = 0;             # keep temporary directory at the end
-my $option = "";            # Not used
-my @pkgs;                   # list of packages
-my $pbtag;                  # Global Tag variable
-my $pbver;                  # Global Version variable
-my $pbscript;               # Name of the script
-my %pbver;                  # per package
-my %pbtag;                  # per package
-my $pbrev;                  # Global REVISION variable
-my $pbaccount;              # Login to use to connect to the VM/RM
-my $pbtarget = undef;       # Target os-ver-arch you want to build for
-my $pbport;                 # Port to use to connect to the VM/RM
-my $newver;                 # New version to create
-my $pbimage = undef;            # ISO image for the VM to create or docker image for the VE
-my $vetype = undef;         # Type of Virtual environment to deal with
+$Global::pb_stop_on_error = 0;      # False by default
+$Global::pb_show_sudo = 0;          # False by default
+
+my %opts;                           # CLI Options
+my $action;                         # action to realize
+my $test = "FALSE";                 # Not used
+my $pbforce = 0;                    # Force VM stop
+my $pbsnap = 0;                     # Do not use snapshot mode for VM/VE by default
+my $pbkeep = 0;                     # keep temporary directory at the end
+my $option = "";                    # Not used
+my @pkgs;                           # list of packages
+my $pbtag;                          # Global Tag variable
+my $pbver;                          # Global Version variable
+my %pbscript;                       # Name of the scripts per V
+my $pbrev;                          # Global REVISION variable
+my $pbaccount;                      # Login to use to connect to the VM/RM
+my $pbtarget = undef;               # Target os-ver-arch you want to build for
+my $pbport;                         # Port to use to connect to the VM/RM
+my $newver;                         # New version to create
+my $pbimage = undef;                # ISO image for the VM to create or docker image for the VE
+my $vetype = undef;                 # Type of Virtual environment to deal with
 
 my @date = pb_get_date();
@@ -740 +738 @@
 }
 if (defined $opts{'s'}) {
-    $pbscript = $opts{'s'};
+    $pbscript{'default'} = $opts{'s'};
 }
 if (defined $opts{'a'}) {
     $pbaccount = $opts{'a'};
-    die "option -a requires a -s script option" if (not defined $pbscript);
+    die "option -a requires a -s script option" if (not defined $pbscript{'default'});
 }
 if (defined $opts{'P'}) {
@@ -870 +868 @@
     pb_build2v("vm","build");
 } elsif ($action =~ /^launchvm$/) {
-    my $pm;
-    my $all_ok = 1;
-    if (defined $pbparallel) {
-        $pm = new Parallel::ForkManager($pbparallel);
-    
-        # Set which port the VM/RM will use to communicate
-        $pm->run_on_start(\&pb_set_port);
-        $pm->run_on_finish(sub { my ($pid, $code, $id, $signal, $dump) = @_;
-                            $all_ok = 0 unless (($code == 0) && ($signal == 0) && ($dump == 0)); 
-                        });
-    }
-
-    my $counter = 0;
-    foreach my $v (split(/,/,$ENV{'PBV'})) {
-        $counter++;
-        # Modulo 2 * pbparallel (to avoid synchronization problems)
-        $counter = 1 if ((defined $pbparallel) && ($counter > 2 * $pbparallel));
-        $pm->start($counter) and next if (defined $pbparallel);
-
-        pb_launchv("vm",$v,0);
-    }
-    $pm->wait_all_children if (defined $pbparallel);
-    die "Aborting, one or more of the children failed." if ((not $all_ok) && ($Global::pb_stop_on_error));
+    pb_parallel_launchv(undef,"vm",undef,3);
 } elsif ($action =~ /^launchve$/) {
-    pb_launchv("ve",$ENV{'PBV'},0);
+    pb_parallel_launchv(undef,"ve",undef,3);
 } elsif ($action =~ /^script2vm$/) {
-    pb_script2v($pbscript,"vm");
+    die "action script2vm requires a -s script option" if (not defined $pbscript{'default'});
+    pb_script2v(\%pbscript,"vm");
 } elsif ($action =~ /^script2ve$/) {
-    pb_script2v($pbscript,"ve");
+    die "action script2ve requires a -s script option" if (not defined $pbscript{'default'});
+    pb_script2v(\%pbscript,"ve");
 } elsif ($action =~ /^script2rm$/) {
-    pb_script2v($pbscript,"rm");
+    die "action script2rm requires a -s script option" if (not defined $pbscript{'default'});
+    pb_script2v(\%pbscript,"rm");
 } elsif ($action =~ /^newver$/) {
     pb_newver();
 } elsif ($action =~ /^newve$/) {
-    pb_launchv("ve",$ENV{'PBV'},1);
+    pb_parallel_launchv(undef,"ve",undef,0);
 } elsif ($action =~ /^newvm$/) {
-    pb_launchv("vm",$ENV{'PBV'},1);
+    pb_parallel_launchv(undef,"vm",undef,0);
     pb_log(0, "Please ensure that sshd is running in your VM by default\n");
     pb_log(0, "and that it allows remote root login (PermitRootLogin yes in /etc/ssh/sshd_config)\n");
@@ -978 +957 @@
     my ($ptr2) = pb_conf_get("vmcmd");
     my $vmcmd = $ptr2->{$ENV{'PBPROJ'}};
-    my ($vmexist,$vmmport) = pb_check_ps($vmcmd,$ENV{'PBV'});
-    if (! $vmexist) {
+    my ($vexist,$vmmport) = pb_check_ps($vmcmd,$ENV{'PBV'});
+    if (! $vexist) {
         pb_log(0,"No VM found for $ENV{'PBV'}\n");
     } else {
-        pb_log(0,"Found an existing VM for $ENV{'PBV'} PID: $vmexist - SSH port: $vmmport\n");
+        pb_log(0,"Found an existing VM for $ENV{'PBV'} PID: $vexist - SSH port: $vmmport\n");
     }
 } elsif ($action =~ /^sbx2webpkg$/) {
@@ -1930 +1909 @@
 
     my $cmt = shift;
+    my $pbscript = shift || undef;
     my $v = shift || undef;
-    my $vmexist = shift || 0;           # 0 is FALSE
-    my $vmpid = shift || 0;             # 0 is FALSE
+    my $vexist = shift || 0;            # 0 is FALSE
+    my $vpid = shift || 0;              # 0 is FALSE
     my $snapme = shift || 0;            # 0 is FALSE
-
-    pb_log(2,"DEBUG: pb_send2target($cmt,".Dumper($v).",$vmexist,$vmpid)\n");
+    my $pbstep = shift || 3;            # 3 is usage of container
+
+    pb_log(2,"DEBUG: pb_send2target($cmt,".Dumper($v).",$vexist,$vpid)\n");
     my $host = "sshhost";
     my $login = "sshlogin";
@@ -2039 +2020 @@
 
     if ($cmt =~ /(V[EM]|RM)build/) {
-        $src="$src $ENV{'PBROOTDIR'}/$ENV{'PBPROJ'}.pb $ENV{'PBDESTDIR'}/$ENV{'PBPROJVER'}-$ENV{'PBPROJTAG'}.pb $ENV{'PBETC'} $ENV{'PBDESTDIR'}/pbrc $ENV{'PBDESTDIR'}/pbscript.$$";
+        $src="$src $ENV{'PBROOTDIR'}/$ENV{'PBPROJ'}.pb $ENV{'PBDESTDIR'}/$ENV{'PBPROJVER'}-$ENV{'PBPROJTAG'}.pb $ENV{'PBETC'} $ENV{'PBDESTDIR'}/pbrc $pbscript{$v}";
     } elsif ($cmt =~ /(V[EM]|RM)Script/) {
-        $src="$src $ENV{'PBDESTDIR'}/pbscript.$$";
+        $src="$src $pbscript{$v}";
     } elsif ($cmt =~ /(V[EM]|RM)test/) {
-        $src="$src $ENV{'PBROOTDIR'}/$ENV{'PBPROJ'}.pb $ENV{'PBDESTDIR'}/$ENV{'PBPROJVER'}-$ENV{'PBPROJTAG'}.pb $ENV{'PBETC'} $ENV{'PBDESTDIR'}/pbrc $ENV{'PBDESTDIR'}/pbscript.$$ $ENV{'PBDESTDIR'}/pbtest";
+        $src="$src $ENV{'PBROOTDIR'}/$ENV{'PBPROJ'}.pb $ENV{'PBDESTDIR'}/$ENV{'PBPROJVER'}-$ENV{'PBPROJTAG'}.pb $ENV{'PBETC'} $ENV{'PBDESTDIR'}/pbrc $pbscript{$v} $ENV{'PBDESTDIR'}/pbtest";
     } elsif (($cmt eq "Announce") || ($cmt eq "Web") || ($cmt eq "CPAN")) {
         $src="$src $ENV{'PBTMP'}/pbscript";
@@ -2052 +2033 @@
         chomp($src);
         close(KEEP);
-        $src = "$src $ENV{'PBBUILDDIR'}/pbscript.$$";
+        $src = "$src $pbscript{$v}";
     }
     if (($cmt eq "Sources") || ($cmt eq "Packages") || ($cmt eq "CPAN")) {
@@ -2189 +2170 @@
 # Prepare a script to ease urpmi setup
 cat > $ENV{'PBPROJ'}$repotag.addmedia << EOT
+#rpm --import $pbrepo->{$ENV{'PBPROJ'}}/$repodir/$ENV{'PBPROJ'}.pubkey
 urpmi.addmedia $ENV{'PBPROJ'}$repotag $pbrepo->{$ENV{'PBPROJ'}}/$repodir with media_info/hdlist.cz
 EOT
@@ -2200 +2182 @@
     genhdlist .
 fi
+(cd media_info ; ln -sf ../$ENV{'PBPROJ'}.pubkey pubkey)
 EOF
             }
@@ -2367 +2350 @@
     my $tpdir;
     my $tp;
+    my $docrepo;
+    my $context = "$ENV{'PBTMP'}";
+    my %tag;
     if ($cmt =~ /^VE/) {
         $tp = pb_path_expand($vepath->{$ENV{'PBPROJ'}});
         $tpdir = pb_path_expand("$tp/$pbos->{'name'}/$pbos->{'version'}/$pbos->{'arch'}");
-        if (not defined $vetype) {
-            my ($ptr) = pb_conf_get("vetype");
-            $vetype = $ptr->{$ENV{'PBPROJ'}};
-        }
+        $vetype = pb_ve_get_type($vetype);
         my $arch = pb_get_arch();
         if ($vetype eq "chroot") {
@@ -2382 +2365 @@
         } elsif ($vetype eq "docker") {
             # docker manages the storage so rely on it
-            $shcmdroot = "sudo /usr/bin/docker $tpdir ";
-            $shcmd = "$shcmdroot /bin/su - $mac -c ";
+            $shcmdroot = "";
+            my ($dockerregistry) = pb_conf_get("dockerregistry");
+            $docrepo = pb_ve_docker_repo($dockerregistry->{$ENV{'PBPROJ'}});
+            my $cmd1 = pb_check_req("docker",0);
+            #my ($dockeropt) =  pb_conf_get_if("dockeropt");
+            # pbimage is used for docker and is setup to the right name depending on the step:
+            # TODO: This is not coded yet
+            my $pbimage = undef;
+            # step 0 : nothing at creation -> tag n-v-a (made below)
+            # step 1 : n-v-a + setup -> tag n-v-a-pb
+            # step 2 : n-v-a-pb + build -> tag n-v-a-pb-pbproj
+            # step 3 : n-v-a-pb-pbproj at use
+            if ((not defined $pbimage) || ($pbimage eq "")) {
+                # If no image name given, create a naming convention
+                $tag{1} = "$docrepo:$pbos->{'name'}-$pbos->{'version'}-$pbos->{'arch'}";
+                $tag{2} = "$tag{1}-pb";
+                $tag{3} = "$tag{2}-$ENV{'PBPROJ'}";
+            } else {
+                # If we were given an image name, just use it
+                $tag{1} = $pbimage;
+                $tag{2} = $pbimage;
+                $tag{3} = $pbimage;
+            }
+            # If we do not create the image, then use the one we should have
+            my $found = pb_ve_docker_get_image($tag{$pbstep});
+            # Now we use that image to do what is needed
+            # use a dockerfile to ease the creation of next images
+            # the context is in an empty temp dir
+            my $tmpd = "$context/Dockerfile";
+            open(DOCKER, "> $tmpd") || die "Unable to create the docker file $tmpd";
+            print DOCKER "FROM $tag{$pbstep}\n";
+            print DOCKER "MAINTAINER project-builder.org aka pb\n";
+            if ($pbstep == 1) {
+                # setup done as root
+                print DOCKER "USER root\n";
+            } else {
+                print DOCKER "USER pb\n";
+            }
+            $shcmd = "$cmd1 build -t $tag{$pbstep+1} $context";
+            #$shcmd = "$cmd1 build $dockeropt->{$ENV{'PBPROJ'}} -t $tag{$pbstep+1} $context";
         }
         $shcmd = "setarch i386 $shcmd" if (($pbos->{'arch'} =~ /i[3456]86/) && ($arch eq 'x86_64'));
         $cpcmd = "sudo /bin/cp -r ";
-        # We need to get the home dir of the target account to deliver in the right place
-        open(PASS,"$tpdir/etc/passwd") || die "Unable to open $tpdir/etc/passwd: $!";
         my $homedir = "";
-        while (<PASS>) {
-            my ($c1,$c2,$c3,$c4,$c5,$c6,$c7) = split(/:/);
-            $homedir = $c6 if ($c1 =~ /^$mac$/);
-            pb_log(3,"Homedir: $homedir - account: $c6\n");
-        }
-        close(PASS);
+        if (($cmt =~ /VE/) && ($vetype ne "docker")) {
+            # We need to get the home dir of the target account to deliver in the right place
+            open(PASS,"$tpdir/etc/passwd") || die "Unable to open $tpdir/etc/passwd: $!";
+            while (<PASS>) {
+                my ($c1,$c2,$c3,$c4,$c5,$c6,$c7) = split(/:/);
+                $homedir = $c6 if ($c1 =~ /^$mac$/);
+                pb_log(3,"Homedir: $homedir - account: $c6\n");
+            }
+            close(PASS);
+        }
         $cptarget = "$tpdir/$homedir/$tdir";
+        if ($vetype eq "docker") {
+            $cptarget = "docker container $shcmd";
+        }
         if ($cmt eq "VEbuild") {
             $cp2target = "$tpdir/$homedir/$bdir";
@@ -2436 +2462 @@
     # Do not touch when just announcing
     if (($cmt ne "Announce") && ($cmt ne "CPAN")) {
-        pb_system("$shcmd \"mkdir -p $tdir ; cd $tdir ; echo \'for i in $basesrc; do if [ -f \$i ]; then rm -f \$i; fi; done\ ; $cmd' | bash -e\"","Preparing $tdir on $cptarget");
+        # For docker everything is done in the Dockerfile
+        if (($cmt =~ /^VE/) && ($vetype eq "docker")) {
+            print DOCKER "RUN mkdir -p $tdir\n";
+            print DOCKER "RUN cd $tdir ; for i in $basesrc; do if [ -f \$i ]; then rm -f \$i; fi; done\n";
+            print DOCKER "RUN $cmd\n" if ((defined $cmd) && ($cmd ne ""));
+        } else {
+            pb_system("$shcmd \"mkdir -p $tdir ; cd $tdir ; echo \'for i in $basesrc; do if [ -f \$i ]; then rm -f \$i; fi; done\ ; $cmd' | bash -e\"","Preparing $tdir on $cptarget");
+        }
     } else {
         $logres = "> ";
     }
-    pb_system("cd $ENV{'PBBUILDDIR'} ; $cpcmd $src $cptarget 2> /dev/null","$cmt delivery in $cptarget");
+    # For docker everything is done in the Dockerfile
+    if (($cmt =~ /^VE/) && ($vetype eq "docker")) {
+        foreach my $f (split(/ +/,$src)) {
+            copy("$f","$context");
+            print DOCKER "ADD ".basename($f)." $tdir/\n";
+        }
+    } else {
+        pb_system("cd $ENV{'PBBUILDDIR'} ; $cpcmd $src $cptarget 2> /dev/null","$cmt delivery in $cptarget");
+    }
 
     # For VE we need to change the owner manually
     if ($cmt =~ /^VE/) {
-        my $sudomode = pb_distro_get_param($pbos,pb_conf_get("ossudoersmode"));
-        my $res = pb_system("$shcmdroot sed -i '/requiretty/d' /etc/sudoers","Removing potential requiretty in sudoers","quiet");
-        pb_system("$shcmdroot sed '/requiretty/d' /etc/sudoers > /tmp/sudoers.new ; mv /tmp/sudoers.new $tpdir/tmp/sudoers.new ; $shcmdroot mv /tmp/sudoers.new /etc/sudoers ; $shcmdroot chown root:root /etc/sudoers ; $shcmdroot chmod $sudomode /etc/sudoers","Removing again potential requiretty in sudoers as sed -i failed") if (($res ne 0) && (-f "$tpdir/etc/sudoers"));
-        pb_system("$shcmd \"sudo chown -R $mac $tdir\"","Adapt owner in $tdir to $mac");
+        if ($vetype ne "docker") {
+            my $sudomode = pb_distro_get_param($pbos,pb_conf_get("ossudoersmode"));
+            my $res = pb_system("$shcmdroot sed -i '/requiretty/d' /etc/sudoers","Removing potential requiretty in sudoers","quiet");
+            pb_system("$shcmdroot sed '/requiretty/d' /etc/sudoers > /tmp/sudoers.new ; mv /tmp/sudoers.new $tpdir/tmp/sudoers.new ; $shcmdroot mv /tmp/sudoers.new /etc/sudoers ; $shcmdroot chown root:root /etc/sudoers ; $shcmdroot chmod $sudomode /etc/sudoers","Removing again potential requiretty in sudoers as sed -i failed") if (($res ne 0) && (-f "$tpdir/etc/sudoers"));
+            pb_system("$shcmd \"sudo chown -R $mac $tdir\"","Adapt owner in $tdir to $mac");
+        }
     }
 
     # Use the right script name depending on context
-    my $pbscript;
+    my $pbscript1;
     if (($cmt =~ /^(V[EM]|RM)/) || ($cmt =~ /Packages/)){
-        $pbscript = "pbscript.$$";
+        $pbscript1 = "$pbscript{$v}";
     } else {
-        $pbscript = "pbscript";
+        $pbscript1 = "pbscript";
     }
 
@@ -2461 +2504 @@
     my $shcmdbase = $shcmd;
     if ($cmt ne "CPAN") {
-        $shcmd .= " \"echo \'cd $tdir ; if [ -x $pbscript ]; then ./$pbscript; fi ; rm -f ./$pbscript\' | bash\"";
+        if (($cmt =~ /^VE/) && ($vetype eq "docker")) {
+            copy("$pbscript1","$context");
+            my $s = basename($pbscript1);
+            print DOCKER "ADD $s $tdir/\n";
+            # sleep to avoid text file busy errors
+            print DOCKER "RUN sleep 2\n";
+            print DOCKER "RUN cd $tdir ; chmod 755 $s ; ./$s ; if [ '$pbkeep' == '0' ]; then rm -f $s; fi\n";
+            close(DOCKER);
+        } else {
+            $shcmd .= " \"echo \'cd $tdir ; if [ -x $pbscript1 ]; then ./$pbscript1; fi ;  if [ '$pbkeep' == '0' ]; then rm -f ./$pbscript1\'; fi | bash\"";
+        }
     }
     my $cmdverb = "verbose";
@@ -2469 +2522 @@
         $cmdverb = "verbose_\[$v\] ";
     }
+    # this is where we lanch the execution
     pb_system("$shcmd","Executing pbscript on $cptarget if needed",$cmdverb);
+
     if ($cmt =~ /^(V[EM]|RM)build/) {
         # Get back info on pkg produced, compute their name and get them from the VM/RM
@@ -2509 +2564 @@
             # We want to send them to the ssh account so overwrite what has been done before
             undef $pbaccount;
-            pb_log(2,"Before sending pkgs, vmexist: $vmexist, vmpid: $vmpid\n");
-            pb_send2target("Packages",$pbos->{'name'}."-".$pbos->{'version'}."-".$pbos->{'arch'},$vmexist,$vmpid);
+            pb_log(2,"Before sending pkgs, vexist: $vexist, vpid: $vpid\n");
+            pb_send2target("Packages","$ENV{'PBDESTDIR'}/pbscript.$$",$pbos->{'name'}."-".$pbos->{'version'}."-".$pbos->{'arch'},$vexist,$vpid);
             pb_rm_rf("$ENV{'PBBUILDDIR'}/$pbos->{'name'}/$pbos->{'version'}/$pbos->{'arch'}");
         }
     }
-    unlink("$ENV{'PBDESTDIR'}/pbscript.$$") if ((($cmt =~ /^(V[ME]|RM)/) || ($cmt =~ /Packages/)) && ($pbkeep eq 0));
-
-    pb_log(2,"Before halt, vmexist: $vmexist, vmpid: $vmpid\n");
-    if ((! $vmexist) && ($cmt =~ /^VM/)) {
+    unlink("$pbscript{$v}") if ((($cmt =~ /^(V[ME]|RM)/) || ($cmt =~ /Packages/)) && ($pbkeep eq 0));
+
+    pb_log(2,"Before halt, vexist: $vexist, vpid: $vpid\n");
+    if ((! $vexist) && ($cmt =~ /^VM/)) {
         # If in setupvm then takes a snapshot just before halting
         if ($snapme != 0) {
@@ -2550 +2605 @@
             $hoption = "" ;
         }
-        pb_system("$shcmdbase \"sudo $hpath $hoption \"; $tm ; echo \'if [ -d /proc/$vmpid ]; then kill -9 $vmpid; fi \' | bash ; sleep 10","VM $v halt (pid $vmpid)");
+        pb_system("$shcmdbase \"sudo $hpath $hoption \"; $tm ; echo \'if [ -d /proc/$vpid ]; then kill -9 $vpid; fi \' | bash ; sleep 10","VM $v halt (pid $vpid)");
     }
     if (($cmt =~ /^VE/) && ($snapme != 0)) {
         pb_ve_snap($pbos,$tp);
+        if ($vetype eq "docker") {
+            foreach my $f (split(/ +/,$src)) {
+                unlink("$context/$f");
+            }
+        }
     }
 }
 
 sub pb_script2v {
-    my $pbscript=shift;
-    my $vtype=shift;
-    my $pbforce=shift || 0; # Force stop of VM. Default not.
-    my $vm1=shift || undef; # Only that VM/VE/RM to treat. Default all.
-    my $snapme=shift || 0;  # Do we have to create a snapshot. Default not.
-    my $vm;
-    my $all;
-
-    pb_log(2,"DEBUG: pb_script2v($pbscript,$vtype,$pbforce,".Dumper($vm1).",$snapme)\n");
-    # Prepare the script to be executed on the VM/VE/RM
-    # in $ENV{'PBDESTDIR'}/pbscript.$$
-    if ((defined $pbscript ) && ($pbscript ne "$ENV{'PBDESTDIR'}/pbscript.$$")) {
-        copy($pbscript,"$ENV{'PBDESTDIR'}/pbscript.$$") || die "Unable to create $ENV{'PBDESTDIR'}/pbscript.$$ from $pbscript";
-        chmod 0755,"$ENV{'PBDESTDIR'}/pbscript.$$";
-    }
-
-    if (not defined $vm1) {
-        ($vm,$all) = pb_get2v($vtype);
+
+my $pbscript=shift;
+my $vtype=shift;
+my $pbstep=shift;   # Which step are we in (0: create, 1: setup, 2: build, 3: use)
+my $pbforce=shift || 0; # Force stop of VM. Default not.
+my $snapme=shift || 0;  # Do we have to create a snapshot. Default not.
+my $pbimage=shift || undef; # Which image to use to start the VM/VE
+my $vm;
+my $all;
+
+pb_log(2,"DEBUG: pb_script2v($vtype,$pbstep,$pbforce,$snapme)\n");
+pb_log(2,"DEBUG: pb_script2v(pbscript: ".Dumper($pbscript)."\n");
+pb_parallel_launchv($pbscript,$vtype,uc($vtype)."Script",$pbstep,$pbforce,$snapme,$pbsnap,$pbimage);
+}
+
+sub pb_parallel_launchv {
+
+my $pbscript=shift;
+my $vtype = shift;
+my $action = shift;             # It an action is defined then use send2target
+my $pbstep=shift;           # Which step are we in (0: create, 1: setup, 2: build 3: use)
+my $pbforce=shift || 0;         # Force stop of VM. Default not.
+my $snapme = shift || 0;        # By default do not snap a VM/VE/RM
+my $usesnap = shift || 1;       # By default study the usage of the snapshot feature of VM/VE/RM    
+my $pbimage=shift || undef;     # Which image to use to start the VM/VE
+my $vm;
+my $all;
+
+# Adapt // mode to memory size
+$pbparallel = pb_set_parallel($vtype);
+
+pb_log(2,"DEBUG: pb_parallel_launch(vtype,step,force,snapme,usesnap: $vtype,$pbstep,$pbforce,$snapme,$usesnap)\n");
+pb_log(2,"DEBUG: pb_parallel_launch(pbscript: ".Dumper($pbscript)."\n");
+
+my ($vexist,$vpid) = (undef,undef);
+my $pm;
+my $all_ok = 1;
+if (defined $pbparallel) {
+    $pm = new Parallel::ForkManager($pbparallel);
+
+    # Set which port the VM/RM will use to communicate
+    $pm->run_on_start(\&pb_set_port);
+    $pm->run_on_finish(sub { my ($pid, $code, $id, $signal, $dump) = @_;
+                            unless ($code == 0 && $signal == 0 && $dump == 0) {
+                                $all_ok = 0;
+                                pb_log(0,"ERROR: pid $pid failed\n");
+                            }
+                        });
+}
+
+# Determine on which V to work
+if (defined $ENV{'PBV'}) {
+    @$vm = split(/,/,$ENV{'PBV'});
+} else {
+    ($vm,$all) = pb_get2v($vtype);
+}
+
+my $counter = 0;
+foreach my $v (@$vm) {
+    $counter++;
+    # Modulo 2 * pbparallel (to avoid synchronization problems)
+    $counter = 1 if ((defined $pbparallel) && ($counter > 2 * $pbparallel));
+    $pm->start($counter) and next if (defined $pbparallel);
+    
+    # Launch a single operation
+    my $pbscript = $pbscript->{$v} if (defined $pbscript->{$v});
+    $pbscript = $pbscript->{'default'} if (not defined $pbscript);
+    die "No script defined so unable to launch it in $v" if (not defined $pbscript);
+    ($vexist,$vpid) = pb_launchv($pbscript,$vtype,$v,$action,$pbstep,$pbforce,$snapme,$pbsnap,$pbimage);
+    
+    # Skip that V if something went wrong
+    if (($vpid == 0) && ($vexist == 0)) {
+        $pm->finish if (defined $pbparallel);
+        next;
+    }
+    $pm->finish if (defined $pbparallel);
+}
+$pm->wait_all_children if (defined $pbparallel);
+die "Aborting, one or more of the children failed." if ((not $all_ok) && ($Global::pb_stop_on_error));
+}
+
+sub pb_launchv {
+
+my $pbscript=shift;
+my $vtype = shift;
+my $v = shift;                  # Only 1 VM/VE/RM treated here
+my $action = shift;             # It an action is defined then use send2target
+my $pbstep=shift;           # Which step are we in (0: create, 1: setup, 2: build 3: use)
+my $pbforce=shift || 0;         # Force stop of VM. Default not.
+my $snapme = shift || 0;        # By default do not snap a VM/VE/RM
+my $usesnap = shift || 1;       # By default study the usage of the snapshot feature of VM/VE/RM    
+my $pbimage=shift || undef;     # Which image to use to start the VM/VE
+my $vexist = undef;
+my $vpid = undef;
+
+# Check that v exists
+die "No VM/VE/RM defined, unable to launch" if (not defined $v);
+
+# If creation or snapshot creation mode, no snapshot usable
+if (($pbstep == 0) || ($snapme == 1)) {
+    $usesnap = 0;
+}
+
+pb_log(2,"DEBUG: pb_launchv(script,vtype,v,step,force,snapme,usesnap: $pbscript,$vtype,$v,$pbstep,$pbforce,$snapme,$usesnap)\n");
+pb_log(2,"DEBUG: pb_launchv(pbimage: $pbimage)\n") if (defined $pbimage);
+pb_log(2,"DEBUG: pb_launchv(action: $action)\n") if (defined $action);
+# Keep only the first VM in case many were given
+if ($v =~ /,/) {
+    pb_log(0,"WARNING: pruning to just the first of several VM/VE/RMs listed ($v)\n");
+    $v =~ s/,.*//;
+}
+
+my $pbos = pb_distro_get_context($v);
+
+pb_apply_conf_proxy($pbos);
+
+# Launch the VMs/VEs
+if ($vtype eq "vm") {
+    die "-i image parameter needed" if (((not defined $pbimage) || ($pbimage eq "")) && ($pbstep == 0));
+
+    my ($ptr,$ptr2,$vmpath,$vmport,$vms) = pb_conf_get("vmtype","vmcmd","vmpath","vmport","vmsize");
+    my ($vmopt,$vmmm,$vmtmout,$vmsnap,$vmbuildtm,$vmmonport) = pb_conf_get_if("vmopt","vmmem","vmtmout","vmsnap","vmbuildtm","vmmonport");
+    my $vmsize = pb_distro_get_param($pbos,$vms);
+
+    my $vmtype = $ptr->{$ENV{'PBPROJ'}};
+    my $vmcmd = $ptr2->{$ENV{'PBPROJ'}};
+
+    if (defined $opts{'g'}) {
+        if (($vmtype eq "kvm") || ($vmtype eq "qemu")) {
+            $ENV{'PBVMOPT'} = "--nographic";
+        }
+    }
+    if (not defined $ENV{'PBVMOPT'}) {
+        $ENV{'PBVMOPT'} = "";
+    }
+    # Save the current status for later restoration
+    $ENV{'PBOLDVMOPT'} = $ENV{'PBVMOPT'};
+    # Set a default timeout of 2 minutes
+    if (not defined $ENV{'PBVMTMOUT'}) {
+        $ENV{'PBVMTMOUT'} = "120";
+    }
+    if (defined $vmopt->{$v}) {
+        $ENV{'PBVMOPT'} .= " $vmopt->{$v}" if ($ENV{'PBVMOPT'} !~ / $vmopt->{$v}/);
+    } elsif (defined $vmopt->{$ENV{'PBPROJ'}}) {
+        $ENV{'PBVMOPT'} .= " $vmopt->{$ENV{'PBPROJ'}}" if ($ENV{'PBVMOPT'} !~ / $vmopt->{$ENV{'PBPROJ'}}/);
+    }
+
+    # How much memory to allocate for VMs
+    if (defined $vmmm) {
+        my $vmmem = pb_distro_get_param($pbos,$vmmm);
+        if (defined $vmmem) {
+            $ENV{'PBVMOPT'} .= " -m $vmmem";
+        }
+    }
+
+    # Are we allowed to use snapshot feature 
+    if ($usesnap == 1) {
+        if ((defined $vmsnap->{$v}) && ($vmsnap->{$v} =~ /true/i)) {
+            $ENV{'PBVMOPT'} .= " -snapshot";
+        } elsif ((defined $vmsnap->{$ENV{'PBPROJ'}}) && ($vmsnap->{$ENV{'PBPROJ'}} =~ /true/i)) {
+            $ENV{'PBVMOPT'} .= " -snapshot";
+        } elsif ($pbsnap eq 1) {
+            $ENV{'PBVMOPT'} .= " -snapshot";
+        }
+    } 
+    if ($snapme != 0) {
+        if (($vmtype eq "kvm") || ($vmtype eq "qemu")) {
+            # Configure the monitoring to automate the creation of the 'pb' snapshot
+            $ENV{'PBVMOPT'} .= " -serial mon:telnet::$vmmonport->{$ENV{'PBPROJ'}},server,nowait" if ((defined $vmmonport) && (defined $vmmonport->{$ENV{'PBPROJ'}}));
+            # In that case no snapshot call needed
+            $ENV{'PBVMOPT'} =~ s/ -snapshot//;
+        }
+    }
+    if (defined $vmtmout->{$v}) {
+        $ENV{'PBVMTMOUT'} = $vmtmout->{$v};
+    } elsif (defined $vmtmout->{$ENV{'PBPROJ'}}) {
+        $ENV{'PBVMTMOUT'} = $vmtmout->{$ENV{'PBPROJ'}};
+    }
+    my $nport = pb_get_port($vmport,$pbos,$vtype);
+
+    my $cmd;
+    my $vmm;        # has to be used for pb_check_ps
+    if (($vmtype eq "qemu") || ($vmtype eq "kvm")) {
+        $vmm = "$vmpath->{$ENV{'PBPROJ'}}/$v.qemu";
+        if (($pbstep == 0) || (defined $pbimage)) {
+            $ENV{'PBVMOPT'} .= " -cdrom $pbimage -boot d";
+        }
+        # Always redirect the network and always try to use a 'pb' snapshot
+        #$cmd = "$vmcmd $ENV{'PBVMOPT'} -net nic,model=virtio -net user,hostfwd=tcp::$nport:22 -loadvm pb $vmm"
+        #$cmd = "$vmcmd $ENV{'PBVMOPT'} -redir tcp:$nport:10.0.2.15:22 $vmm"
+        $cmd = "$vmcmd $ENV{'PBVMOPT'} -net nic -net user,hostfwd=tcp:127.0.0.1:$nport-:22 $vmm"
+    } elsif ($vmtype eq "xen") {
+    } elsif ($vmtype eq "vmware") {
     } else {
-        @$vm = ($vm1);
-    }
-    my ($vmexist,$vmpid) = (undef,undef);
-
-    foreach my $v (@$vm) {
-        # Launch VM/VE
-        ($vmexist,$vmpid) = pb_launchv($vtype,$v,0,$snapme,$pbsnap);
-
-        if ($vtype eq "vm") {
-            pb_log(2,"DEBUG: After pb_launchv, vmexist: $vmexist, vmpid: $vmpid\n");
-
-            # Skip that VM/RM if something went wrong
-            next if (($vmpid == 0) && ($vmexist == 0));
-
-            # If force stopping the VM then reset vmexist
-            if ($pbforce == 1) {
-                $vmpid = $vmexist;
-                $vmexist = 0;
-            }
+        die "VM of type $vmtype not supported. Report to the dev team";
+    }
+    # Restore the ENV VAR Value
+    $ENV{'PBVMOPT'} = $ENV{'PBOLDVMOPT'};
+
+    my ($tmpcmd,$void) = split(/ +/,$cmd);
+    my $vmmport = undef;
+    ($vexist,$vmmport) = pb_check_ps($tmpcmd,$vmm);
+    my $vpid = 0;
+    if (! $vexist) {
+        if ($pbstep == 0) {
+            die("Found an existing Virtual machine $vmm. Won't overwrite") if (-r $vmm);
+            if (($vmtype eq "qemu") || ($vmtype eq "xen") || ($vmtype eq "kvm")) {
+                my $command = pb_check_req("qemu-img",0);
+                pb_system("$command create -f qcow2 $vmm $vmsize","Creating the QEMU VM");
+            } elsif ($vmtype eq "vmware") {
+            } else {
+            }
+        }
+        if (! -f "$vmm") {
+            pb_log(0,"Unable to find VM $vmm\n");
         } else {
-            #VE
-            $vmexist = 0;
-            $vmpid = 0;
-        }
-
-        # Gather all required files to send them to the VM/VE/RM
-        # and launch the build through pbscript
-        pb_log(2,"DEBUG: Before send2target, vmexist: $vmexist, vmpid: $vmpid\n");
-        pb_send2target(uc($vtype)."Script","$v",$vmexist,$vmpid,$snapme);
-
-    }
-}
-
-sub pb_launchv {
-    my $vtype = shift;
-    my $v = shift;
-    my $create = shift || 0;        # By default do not create a VM/VE/RM
-    my $snapme = shift || 0;        # By default do not snap a VM/VE/RM
-    my $usesnap = shift || 1;       # By default study the usage of the snapshot feature of VM/VE/RM    
-
-    # If creation or snapshot creation mode, no snapshot usable
-    if (($create == 1) || ($snapme == 1)) {
-        $usesnap = 0;
-    }
-
-    pb_log(2,"DEBUG: pb_launchv($vtype,$v,$create,$snapme,$usesnap)\n");
-    die "No VM/VE/RM defined, unable to launch" if (not defined $v);
-    # Keep only the first VM in case many were given
-    if ($v =~ /,/) {
-        pb_log(0,"WARNING: pruning to just the first of several VM/VE/RMs listed ($v)\n");
-        $v =~ s/,.*//;
-    }
-
+            # Is the SSH port free? if not kill the existing process using it after a build timeout period
+            my ($vmssh,$void) = pb_check_ps($tmpcmd,$vmm);
+            if ($vmssh) {
+                my $buildtm = $ENV{'PBVMTMOUT'};
+                if (defined $vmbuildtm->{$v}) {
+                    $buildtm = $vmbuildtm->{$v};
+                } elsif (defined $vmbuildtm->{$ENV{'PBPROJ'}}) {
+                    $buildtm = $vmbuildtm->{$ENV{'PBPROJ'}};
+                }
+
+                sleep $buildtm;
+                pb_log(0,"WARNING: Killing the process ($vmssh) using port $void (previous failed VM ?)\n");
+                kill 15,$vmssh;
+                # Let it time to exit
+                sleep 5;
+            }
+            pb_system("$cmd &","Launching the VM $vmm");
+            # Using system allows to kill it externaly if needed,sosupport that in the call
+            pb_system("sleep $ENV{'PBVMTMOUT'}","Waiting $ENV{'PBVMTMOUT'} s for VM $v to come up","mayfail");
+            ($vpid,$void) = pb_check_ps($tmpcmd,$vmm);
+            pb_log(0,"VM $vmm launched (pid $vpid)\n");
+        }
+    } else {
+        pb_log(0,"Found an existing VM $vmm (pid $vexist)\n");
+        # Set the correct port here based on what is done
+        $pbport = $vmmport;
+        $vpid = $vexist;
+    }
+    pb_log(2,"DEBUG: pb_launchv returns ($vexist,$vpid)\n");
+    
+    # Skip that VM/RM if something went wrong
+    return($vexist,$vpid) if (($vpid == 0) && ($vexist == 0));
+    
+    # If force stopping the VM then reset vexist
+    if ($pbforce == 1) {
+        $vpid = $vexist;
+        $vexist = 0;
+    }
+} elsif ($vtype eq "ve") {
+    # Force the creation of the VE and no snapshot usable
+    $vetype = pb_ve_get_type($vetype);
+    pb_ve_launch($v,$pbscript,$pbforce,$pbstep,$usesnap,$vetype,$pbimage);
+    $vexist = 0;
+    $vpid = 0;
+} else {
+    # RM here
+    # Get distro context
     my $pbos = pb_distro_get_context($v);
-    
-    pb_apply_conf_proxy($pbos);
-
-    # Launch the VMs/VEs
-    if ($vtype eq "vm") {
-        die "-i image parameter needed" if (((not defined $pbimage) || ($pbimage eq "")) && ($create != 0));
-
-        my ($ptr,$ptr2,$vmpath,$vmport,$vms) = pb_conf_get("vmtype","vmcmd","vmpath","vmport","vmsize");
-        my ($vmopt,$vmmm,$vmtmout,$vmsnap,$vmbuildtm,$vmmonport) = pb_conf_get_if("vmopt","vmmem","vmtmout","vmsnap","vmbuildtm","vmmonport");
-        my $vmsize = pb_distro_get_param($pbos,$vms);
-
-        my $vmtype = $ptr->{$ENV{'PBPROJ'}};
-        my $vmcmd = $ptr2->{$ENV{'PBPROJ'}};
-
-        if (defined $opts{'g'}) {
-            if (($vmtype eq "kvm") || ($vmtype eq "qemu")) {
-                $ENV{'PBVMOPT'} = "--nographic";
-            }
-        }
-        if (not defined $ENV{'PBVMOPT'}) {
-            $ENV{'PBVMOPT'} = "";
-        }
-        # Save the current status for later restoration
-        $ENV{'PBOLDVMOPT'} = $ENV{'PBVMOPT'};
-        # Set a default timeout of 2 minutes
-        if (not defined $ENV{'PBVMTMOUT'}) {
-            $ENV{'PBVMTMOUT'} = "120";
-        }
-        if (defined $vmopt->{$v}) {
-            $ENV{'PBVMOPT'} .= " $vmopt->{$v}" if ($ENV{'PBVMOPT'} !~ / $vmopt->{$v}/);
-        } elsif (defined $vmopt->{$ENV{'PBPROJ'}}) {
-            $ENV{'PBVMOPT'} .= " $vmopt->{$ENV{'PBPROJ'}}" if ($ENV{'PBVMOPT'} !~ / $vmopt->{$ENV{'PBPROJ'}}/);
-        }
-
-        # How much memory to allocate for VMs
-        if (defined $vmmm) {
-            my $vmmem = pb_distro_get_param($pbos,$vmmm);
-            if (defined $vmmem) {
-                $ENV{'PBVMOPT'} .= " -m $vmmem";
-            }
-        }
-
-        # Are we allowed to use snapshot feature 
-        if ($usesnap == 1) {
-            if ((defined $vmsnap->{$v}) && ($vmsnap->{$v} =~ /true/i)) {
-                $ENV{'PBVMOPT'} .= " -snapshot";
-            } elsif ((defined $vmsnap->{$ENV{'PBPROJ'}}) && ($vmsnap->{$ENV{'PBPROJ'}} =~ /true/i)) {
-                $ENV{'PBVMOPT'} .= " -snapshot";
-            } elsif ($pbsnap eq 1) {
-                $ENV{'PBVMOPT'} .= " -snapshot";
-            }
-        } 
-        if ($snapme != 0) {
-            if (($vmtype eq "kvm") || ($vmtype eq "qemu")) {
-                # Configure the monitoring to automate the creation of the 'pb' snapshot
-                $ENV{'PBVMOPT'} .= " -serial mon:telnet::$vmmonport->{$ENV{'PBPROJ'}},server,nowait" if ((defined $vmmonport) && (defined $vmmonport->{$ENV{'PBPROJ'}}));
-                # In that case no snapshot call needed
-                $ENV{'PBVMOPT'} =~ s/ -snapshot//;
-            }
-        }
-        if (defined $vmtmout->{$v}) {
-            $ENV{'PBVMTMOUT'} = $vmtmout->{$v};
-        } elsif (defined $vmtmout->{$ENV{'PBPROJ'}}) {
-            $ENV{'PBVMTMOUT'} = $vmtmout->{$ENV{'PBPROJ'}};
-        }
-        my $nport = pb_get_port($vmport,$pbos,$vtype);
-    
-        my $cmd;
-        my $vmm;        # has to be used for pb_check_ps
-        if (($vmtype eq "qemu") || ($vmtype eq "kvm")) {
-            $vmm = "$vmpath->{$ENV{'PBPROJ'}}/$v.qemu";
-            if (($create != 0) || (defined $pbimage)) {
-                $ENV{'PBVMOPT'} .= " -cdrom $pbimage -boot d";
-            }
-            # Always redirect the network and always try to use a 'pb' snapshot
-            #$cmd = "$vmcmd $ENV{'PBVMOPT'} -net nic,model=virtio -net user,hostfwd=tcp::$nport:22 -loadvm pb $vmm"
-            #$cmd = "$vmcmd $ENV{'PBVMOPT'} -redir tcp:$nport:10.0.2.15:22 $vmm"
-            $cmd = "$vmcmd $ENV{'PBVMOPT'} -net nic -net user,hostfwd=tcp:127.0.0.1:$nport-:22 $vmm"
-        } elsif ($vmtype eq "xen") {
-        } elsif ($vmtype eq "vmware") {
-        } else {
-            die "VM of type $vmtype not supported. Report to the dev team";
-        }
-        # Restore the ENV VAR Value
-        $ENV{'PBVMOPT'} = $ENV{'PBOLDVMOPT'};
-
-        my ($tmpcmd,$void) = split(/ +/,$cmd);
-        my ($vmexist,$vmmport) = pb_check_ps($tmpcmd,$vmm);
-        my $vmpid = 0;
-        if (! $vmexist) {
-            if ($create != 0) {
-                die("Found an existing Virtual machine $vmm. Won't overwrite") if (-r $vmm);
-                if (($vmtype eq "qemu") || ($vmtype eq "xen") || ($vmtype eq "kvm")) {
-                    my $command = pb_check_req("qemu-img",0);
-                    pb_system("$command create -f qcow2 $vmm $vmsize","Creating the QEMU VM");
-                } elsif ($vmtype eq "vmware") {
-                } else {
-                }
-            }
-            if (! -f "$vmm") {
-                pb_log(0,"Unable to find VM $vmm\n");
-            } else {
-                # Is the SSH port free? if not kill the existing process using it after a build timeout period
-                my ($vmssh,$void) = pb_check_ps($tmpcmd,$vmm);
-                if ($vmssh) {
-                    my $buildtm = $ENV{'PBVMTMOUT'};
-                    if (defined $vmbuildtm->{$v}) {
-                        $buildtm = $vmbuildtm->{$v};
-                    } elsif (defined $vmbuildtm->{$ENV{'PBPROJ'}}) {
-                        $buildtm = $vmbuildtm->{$ENV{'PBPROJ'}};
-                    }
-
-                    sleep $buildtm;
-                    pb_log(0,"WARNING: Killing the process ($vmssh) using port $void (previous failed VM ?)\n");
-                    kill 15,$vmssh;
-                    # Let it time to exit
-                    sleep 5;
-                }
-                pb_system("$cmd &","Launching the VM $vmm");
-                # Using system allows to kill it externaly if needed,sosupport that in the call
-                pb_system("sleep $ENV{'PBVMTMOUT'}","Waiting $ENV{'PBVMTMOUT'} s for VM $v to come up","mayfail");
-                ($vmpid,$void) = pb_check_ps($tmpcmd,$vmm);
-                pb_log(0,"VM $vmm launched (pid $vmpid)\n");
-            }
-        } else {
-            pb_log(0,"Found an existing VM $vmm (pid $vmexist)\n");
-            # Set the correct port here based on what is done
-            $pbport = $vmmport;
-            $vmpid = $vmexist;
-        }
-        pb_log(2,"DEBUG: pb_launchv returns ($vmexist,$vmpid)\n");
-        return($vmexist,$vmpid);
-    } elsif ($vtype eq "ve") {
-        # Force the creation of the VE and no snapshot usable
-        pb_ve_launch($v,$create,$usesnap,$vetype,$pbimage);
-    } else {
-        # RM here
-        # Get distro context
-        my $pbos = pb_distro_get_context($v);
-
-        # Get RM context
-        my ($ptr,$rmpath) = pb_conf_get("rmtype","rmpath");
-
-        # Nothing more to do for RM. No real launch
-        # For the moment we support the RM is already running
-        # For ProLiant may be able to power them on if needed later on as an example.
-    }
+
+    # Get RM context
+    my ($ptr,$rmpath) = pb_conf_get("rmtype","rmpath");
+
+    # Nothing more to do for RM. No real launch
+    # For the moment we support the RM is already running
+    # For ProLiant may be able to power them on if needed later on as an example.
+    $vexist = 0;
+    $vpid = 0;
+}
+
+# Gather all required files to send them to the VM/VE/RM
+# and launch the build through pbscript
+if (defined $action) {
+    pb_log(2,"DEBUG: Before send2target, vexist: $vexist, vpid: $vpid, vtype: $vtype, v: $v, action: $action\n");
+    pb_send2target($action,$pbscript,$v,$vexist,$vpid,$snapme,$pbstep);
+}
+return($vexist,$vpid);
 }
 
@@ -2821 +2943 @@
 my $vtype = shift;
 my $action = shift || "build";
-
+my $pbstep = 2;
+my $pbforce=shift || 0;         # Force stop of VM. Default not.
+
+# We prepare scripts for all V of this vtype to allow sharing that part
 my ($v,$all) = pb_get2v($vtype);
 
@@ -2830 +2955 @@
 $pbparallel = pb_set_parallel($vtype);
 
-my ($vmexist,$vmpid) = (undef,undef);
+my ($vexist,$vpid) = (undef,undef);
 my $pm;
 my $all_ok = 1;
@@ -2854 +2979 @@
     # Prepare the script to be executed on the VM/VE/RM
     # in $ENV{'PBDESTDIR'}/pbscript.$$
-    open(SCRIPT,"> $ENV{'PBDESTDIR'}/pbscript.$$") || die "Unable to create $ENV{'PBDESTDIR'}/pbscript.$$";
+    #
+    $pbscript{$v} = "$ENV{'PBDESTDIR'}/pbscript.$$";
+    open(SCRIPT,"> $pbscript{$v}") || die "Unable to create $pbscript{$v}";
     print SCRIPT "#!/bin/bash\n";
 
@@ -2884 +3011 @@
 
     # VE needs a good /proc, tolerate one being potentially left around after a failure
-    if ($vtype eq "ve") {
+    if (($vtype eq "ve") && ($vetype ne "docker")) {
         print SCRIPT "[ -d /proc/1 ] || sudo /bin/mount -t proc /proc /proc\n";
     }
@@ -2937 +3064 @@
     print SCRIPT "pb $verbose -p $ENV{'PBPROJ'} $action"."2pkg $p\n";
 
-    if ($vtype eq "ve") {
+    if (($vtype eq "ve") && ($vetype ne "docker")) {
         print SCRIPT "sudo /bin/umount /proc\n";
     }
@@ -2954 +3081 @@
     print SCRIPT "echo ==== End of script $$ for $vtype $v =====\n";
     close(SCRIPT);
-    chmod 0755,"$ENV{'PBDESTDIR'}/pbscript.$$";
+    chmod 0755,"$pbscript{$v}";
     
-    # Launch the VM/VE/RM
-    ($vmexist,$vmpid) = pb_launchv($vtype,$v,0);
-
-
-    if ($vtype eq "vm") {
-        # Skip that VM if something went wrong
-        if (($vmpid == 0) && ($vmexist == 0)) {
-            $pm->finish if (defined $pbparallel);
-            next;
-        }
-    } else {
-        # VE/RM
-        $vmexist = 0;
-        $vmpid = 0;
-    }
-    # Gather all required files to send them to the VM/VE
-    # and launch the build through pbscript
-    pb_log(2,"Calling send2target $vtype,$v,$vmexist,$vmpid\n");
-    pb_send2target(uc($vtype).$action,"$v",$vmexist,$vmpid);
     $pm->finish if (defined $pbparallel);
 }
 $pm->wait_all_children if (defined $pbparallel);
 die "Aborting, one or more of the children failed." if ((not $all_ok) && ($Global::pb_stop_on_error));
+
+# Launch the VM/VE/RM
+# docker image to use if needed
+# Gather all required files to send them to the VM/VE
+# and launch the build through pbscript
+pb_parallel_launchv(\%pbscript,$vtype,uc($vtype).$action,$pbstep,$pbforce,0,1,$pbimage);
 }
 
@@ -3145 +3259 @@
 my $vtype = shift;
 my $sbx = shift || undef;
+my $pbstep = 1;
 
 my ($vm,$all) = pb_get2v($vtype);
-
-# Script generated
-my $pbscript = "$ENV{'PBDESTDIR'}/setupv.$$";
 
 # Adapt // mode to memory size
@@ -3168 +3280 @@
 my $counter = 0;
 foreach my $v (@$vm) {
+    # Script generated - should be before the fork - after the %pbscript hash isn't updated correctly
+    $pbscript{$v} = "$ENV{'PBDESTDIR'}/setupv-$v";
+
     $counter++;
     # Modulo 2 * pbparallel (to avoid synchronization problems)
@@ -3183 +3298 @@
     my ($pbac) = pb_conf_get($vtype."login");
     my ($key,$zero0,$zero1,$zero2);
-    my ($vmexist,$vmpid);
+    my ($vexist,$vpid);
 
     # Prepare the script to be executed on the VM/VE/RM
     # in $ENV{'PBDESTDIR'}/setupv
-    open(SCRIPT,"> $pbscript") || die "Unable to create $pbscript";
+
+    pb_log(2,"Preparing setup script for $v in $pbscript{$v}\n");
+    open(SCRIPT,"> $pbscript{$v}") || die "Unable to create $pbscript{$v}";
     
     print SCRIPT << 'EOF';
@@ -3219 +3336 @@
 
 EOF
-
-    # Launch the VM/VE/RM - Usage of snapshot disabled
-    ($vmexist,$vmpid) = pb_launchv($vtype,$v,0,0,0);
 
     my $keyfile;
@@ -3236 +3350 @@
     
         # Skip that VM/RM if something went wrong
-        next if (($vmpid == 0) && ($vmexist == 0));
+        next if (($vpid == 0) && ($vexist == 0));
     
         # Store the pub key part in a variable
@@ -3249 +3363 @@
         # once this is done, we can do what we need on the VM/RM remotely
     } elsif ($vtype eq "ve") {
-        print SCRIPT << "EOF";
+        if ($vetype ne "docker") {
+            print SCRIPT << "EOF";
 # For VE we first need to mount some FS
 pb_system("mount -t proc /proc /proc") unless (-d "/proc/$$");
-
+EOF
+        }
+        print SCRIPT << "EOF";
 # For VE we need a good null dev
 # Except for RedHat 6.2 where it's good and doesnt like being recreated
@@ -3565 +3682 @@
 pb_system("pbdistrocheck",undef,"verbose");
 EOF
-    if ($vtype eq "ve") {
+    if ($vtype eq "ve"){
+        if ($vetype ne "docker") {
             print SCRIPT << 'EOF';
 # For VE we need to umount some FS at the end
 
 pb_system("umount /proc","Unmounting /proc","mayfail");
-
+EOF
+        }
+        print SCRIPT << 'EOF';
 # Create a basic network file if not already there
 
@@ -3612 +3732 @@
 EOF
     close(SCRIPT);
-    chmod 0755,"$pbscript";
+    chmod 0755,"$pbscript{$v}";
 
     # That build script needs to be run as root and force stop of VM at end
@@ -3618 +3738 @@
 
     # Force shutdown of VM except if it was already launched
+    # TODO: FIX here as it doesn't work anymore
     my $pbforce = 0;
-    if ((! $vmexist) && ($vtype eq "vm")) {
+    if ((! $vexist) && ($vtype eq "vm")) {
         $pbforce = 1;
     }
     
-    pb_script2v($pbscript,$vtype,$pbforce,$v);
     $pm->finish if (defined $pbparallel);
 }
 $pm->wait_all_children if (defined $pbparallel);
 die "Aborting, one or more of the children failed." if ((not $all_ok) && ($Global::pb_stop_on_error));
+
+# Launch the VM/VE/RM
+pb_log(2,"DEBUG: before parallel launch, pbscript hash is:".Dumper(%pbscript)."\n");
+pb_parallel_launchv(\%pbscript,$vtype,uc($vtype)."Script",$pbstep,$pbforce);
 return;
 }
@@ -3635 +3759 @@
 
 my $vtype = shift;
+my $pbstep = 3;
 
 my ($vm,$all) = pb_get2v($vtype);
@@ -3667 +3792 @@
     # Force shutdown of VM/VE
     # Force snapshot of VM/VE
-    pb_script2v($pbscript,$vtype,1,$v,1);
+    pb_script2v($pbscript,$vtype,$pbstep,1,$v,1);
 }
 return;
@@ -3676 +3801 @@
 
 my $vtype = shift;
+my $pbstep = 2;
 
 my ($vm,$all) = pb_get2v($vtype);
@@ -3697 +3823 @@
 EOF
     # VE needs a good /proc
-    if ($vtype eq "ve") {
+    if (($vtype eq "ve") && ($vetype ne "docker")) {
         print SCRIPT "sudo /bin/mount -t proc /proc /proc\n";
     }
     print SCRIPT "$pbos->{'update'}\n";
-    if ($vtype eq "ve") {
+    if (($vtype eq "ve") && ($vetype ne "docker")) {
         print SCRIPT "sudo /bin/umount /proc\n";
     }
@@ -3708 +3834 @@
 
     # Force shutdown of VM except
-    pb_script2v($pbscript,$vtype,1,$v);
+    pb_script2v($pbscript,$vtype,$pbstep,1,$v);
 }
 return;
@@ -3854 +3980 @@
     close(PBS);
     chmod 0755,"$ENV{'PBTMP'}/pbscript";
-    pb_send2target("Announce");
+    pb_send2target("Announce","$ENV{'PBTMP'}/pbscript");
 
     my $sl = "Project $ENV{'PBPROJ'} version $ENV{'PBPROJVER'} is now available";
@@ -4211 +4337 @@
     my $vmcmd = shift;
     my $vmm = shift;
-    my $vmexist = 0;        # FALSE by default
+    my $vexist = 0;     # FALSE by default
     my $vmport = undef;         # NONE by default
 
@@ -4219 +4345 @@
         next if (! /$vmm/);
         my $void1;
-        ($void1, $vmexist, $vmport) = split(/ +/,$_,3);
+        ($void1, $vexist, $vmport) = split(/ +/,$_,3);
         pb_log(2,"pb_check_ps $vmport\n");
         $vmport =~ s/.*=tcp:127\.0\.0\.1:([0-9]+)-:22.*/$1/;
         chomp($vmport);
-        pb_log(2,"pb_check_ps found a VM $vmexist using port $vmport\n");
+        pb_log(2,"pb_check_ps found a VM $vexist using port $vmport\n");
         last;
     }
-    return($vmexist,$vmport);
+    return($vexist,$vmport);
 }