| 1 | #!/usr/bin/perl -w
|
|---|
| 2 | #
|
|---|
| 3 | # Project Builder main application
|
|---|
| 4 | #
|
|---|
| 5 | # $Id$
|
|---|
| 6 | #
|
|---|
| 7 | # Copyright B. Cornec 2007-2016
|
|---|
| 8 | # Eric Anderson's changes are (c) Copyright 2012 Hewlett Packard
|
|---|
| 9 | # Provided under the GPL v2
|
|---|
| 10 |
|
|---|
| 11 | # Syntax: see at end
|
|---|
| 12 |
|
|---|
| 13 | use strict 'vars';
|
|---|
| 14 |
|
|---|
| 15 | # The modules mentioned here are required by pb when used both
|
|---|
| 16 | # locally or inside a VE/VM/RM
|
|---|
| 17 | # Additional required modules only used locally are called with a require
|
|---|
| 18 | # in their respective section
|
|---|
| 19 | use Getopt::Long qw(:config auto_abbrev no_ignore_case);
|
|---|
| 20 | use Carp qw/confess cluck/;
|
|---|
| 21 | use Data::Dumper;
|
|---|
| 22 | use English;
|
|---|
| 23 | use File::Basename;
|
|---|
| 24 | use File::Copy;
|
|---|
| 25 | use File::stat;
|
|---|
| 26 | use File::Find;
|
|---|
| 27 | use Time::localtime qw(localtime);
|
|---|
| 28 | use POSIX qw(strftime);
|
|---|
| 29 | use lib qw (lib);
|
|---|
| 30 | use ProjectBuilder::Version;
|
|---|
| 31 | use ProjectBuilder::Base;
|
|---|
| 32 | use ProjectBuilder::Display;
|
|---|
| 33 | use ProjectBuilder::Conf;
|
|---|
| 34 | use ProjectBuilder::Distribution;
|
|---|
| 35 | use ProjectBuilder::VCS;
|
|---|
| 36 | use ProjectBuilder::CMS;
|
|---|
| 37 | use ProjectBuilder::Env;
|
|---|
| 38 | use ProjectBuilder::Filter;
|
|---|
| 39 | use ProjectBuilder::Changelog;
|
|---|
| 40 | use ProjectBuilder::VE;
|
|---|
| 41 |
|
|---|
| 42 | # Global variables
|
|---|
| 43 | $Global::pb_stop_on_error = 0; # False by default
|
|---|
| 44 | $Global::pb_show_sudo = 0; # False by default
|
|---|
| 45 |
|
|---|
| 46 | my %opts; # CLI Options
|
|---|
| 47 | my $action; # action to realize
|
|---|
| 48 | my $test = "FALSE"; # Not used
|
|---|
| 49 | my $pbforce = 0; # Force VM stop
|
|---|
| 50 | my $pbsnap = 0; # Do not use snapshot mode for VM/VE by default
|
|---|
| 51 | my $pbkeep = 0; # keep temporary directory at the end
|
|---|
| 52 | my $option = ""; # Not used
|
|---|
| 53 | my @pkgs; # list of packages
|
|---|
| 54 | my $pbtag; # Global Tag variable
|
|---|
| 55 | my $pbver; # Global Version variable
|
|---|
| 56 | my %pbscript; # Name of the scripts per V
|
|---|
| 57 | my $pbrev; # Global REVISION variable
|
|---|
| 58 | my $pbtarget = undef; # Target os-ver-arch you want to build for
|
|---|
| 59 | my $pbport; # Port to use to connect to the VM/RM
|
|---|
| 60 | my $newver; # New version to create
|
|---|
| 61 | my $pbimage = undef; # ISO image for the VM to create or docker image for the VE
|
|---|
| 62 | my $vetype = undef; # Type of Virtual environment to deal with
|
|---|
| 63 |
|
|---|
| 64 | my @date = pb_get_date();
|
|---|
| 65 | my $pbdate = strftime("%Y-%m-%d", @date);
|
|---|
| 66 |
|
|---|
| 67 | =pod
|
|---|
| 68 |
|
|---|
| 69 | =head1 NAME
|
|---|
| 70 |
|
|---|
| 71 | pb, aka project-builder.org - builds packages for your projects
|
|---|
| 72 |
|
|---|
| 73 | =head1 DESCRIPTION
|
|---|
| 74 |
|
|---|
| 75 | pb helps you build various packages directly from your project sources.
|
|---|
| 76 | Those sources could be handled by a CMS (Configuration Management System)
|
|---|
| 77 | such as Subversion, CVS, Git, Mercurial... or being a simple reference to a compressed tar file.
|
|---|
| 78 | It's based on a set of configuration files, a set of provided macros to help
|
|---|
| 79 | you keeping build files as generic as possible. For example, a single .spec
|
|---|
| 80 | file should be required to generate for all rpm based distributions, even
|
|---|
| 81 | if you could also have multiple .spec files if required.
|
|---|
| 82 |
|
|---|
| 83 | =head1 SYNOPSIS
|
|---|
| 84 |
|
|---|
| 85 | pb [-vhSq][-r pbroot][-p project][[-s script -a account -P port][-T VEtype][-t [os-ver-arch]][-m os-ver-arch[,...]]][-g][-i image] <action> [<pkg1> ...]
|
|---|
| 86 |
|
|---|
| 87 | pb [--verbose][--help][--man][--quiet][--snapshot][--revision pbroot][--project project][[--script script --account account --port port][-T VEtype][--target [os-ver-arch]][--machine os-ver-arch[,...]]][--nographic][--image image][--rebuild] <action> [<pkg1> ...]
|
|---|
| 88 |
|
|---|
| 89 | =head1 OPTIONS
|
|---|
| 90 |
|
|---|
| 91 | =over 4
|
|---|
| 92 |
|
|---|
| 93 | =item B<-v|--verbose>
|
|---|
| 94 |
|
|---|
| 95 | Increase verbosity
|
|---|
| 96 |
|
|---|
| 97 | =item B<-q|--quiet>
|
|---|
| 98 |
|
|---|
| 99 | Do not print any output.
|
|---|
| 100 |
|
|---|
| 101 | =item B<-h|--help>
|
|---|
| 102 |
|
|---|
| 103 | Print a brief help message and exits.
|
|---|
| 104 |
|
|---|
| 105 | =item B<-S|--snapshot>
|
|---|
| 106 |
|
|---|
| 107 | Use the snapshot mode of VMs or VEs
|
|---|
| 108 |
|
|---|
| 109 | =item B<--man>
|
|---|
| 110 |
|
|---|
| 111 | Prints the manual page and exits.
|
|---|
| 112 |
|
|---|
| 113 | =item B<-t|--target os-ver-arch>
|
|---|
| 114 |
|
|---|
| 115 | Name of the target system you want to build for.
|
|---|
| 116 | All if none precised.
|
|---|
| 117 |
|
|---|
| 118 | =item B<-m|--machine os-ver-arch[,os-ver-arch,...]>
|
|---|
| 119 |
|
|---|
| 120 | Name of the Virtual Machines (VM), Virtual Environments (VE) or Remote Machines (RM)
|
|---|
| 121 | you want to build on (comma separated).
|
|---|
| 122 | All if none precised (or use the env variable PBV).
|
|---|
| 123 |
|
|---|
| 124 | =item B<-T|--vetype VEtype]>
|
|---|
| 125 |
|
|---|
| 126 | Type of Virtual Environments (VE)
|
|---|
| 127 | Can be chroot or docker.
|
|---|
| 128 |
|
|---|
| 129 | =item B<-s|--script script>
|
|---|
| 130 |
|
|---|
| 131 | Name of the script you want to execute on the related VMs/VEs/RMs.
|
|---|
| 132 |
|
|---|
| 133 | =item B<-g|--nographic>
|
|---|
| 134 |
|
|---|
| 135 | Do not launch VMs in graphical mode.
|
|---|
| 136 |
|
|---|
| 137 | =item B<-i|--image image>
|
|---|
| 138 |
|
|---|
| 139 | It could be either:
|
|---|
| 140 | - The name of the ISO image of the distribution you want to install on the related VMs
|
|---|
| 141 | - The name of the docker image of the distribution you want to install on the related VEs
|
|---|
| 142 |
|
|---|
| 143 |
|
|---|
| 144 | =item B<-a|--account account>
|
|---|
| 145 |
|
|---|
| 146 | Name of the account to use to connect on the related VMs/RMs.
|
|---|
| 147 |
|
|---|
| 148 | =item B<-P|--port port_number>
|
|---|
| 149 |
|
|---|
| 150 | Port number to use to connect on the related VMs/RMs.";
|
|---|
| 151 |
|
|---|
| 152 | =item B<-p|--project project_name>
|
|---|
| 153 |
|
|---|
| 154 | Name of the project you're working on (or use the env variable PBPROJ)
|
|---|
| 155 |
|
|---|
| 156 | =item B<-r|--revision revision>
|
|---|
| 157 |
|
|---|
| 158 | Path Name of the project revision under the CMS (or use the env variable PBROOT)
|
|---|
| 159 |
|
|---|
| 160 | =item B<-V|--version new_version>
|
|---|
| 161 |
|
|---|
| 162 | New version of the project to create based on the current one.
|
|---|
| 163 |
|
|---|
| 164 | =item B<-k|--keep>
|
|---|
| 165 |
|
|---|
| 166 | Keep the temporary dir where files have been created in or der to help debug
|
|---|
| 167 |
|
|---|
| 168 | =item B<--rebuild>
|
|---|
| 169 |
|
|---|
| 170 | Only valid with the checkssh action, it alllows to automatically relaunch the build of the failed packages
|
|---|
| 171 |
|
|---|
| 172 | =item B<--no-stop-on-error>
|
|---|
| 173 |
|
|---|
| 174 | Continue through errors with best effort.
|
|---|
| 175 |
|
|---|
| 176 | =back
|
|---|
| 177 |
|
|---|
| 178 | =head1 ARGUMENTS
|
|---|
| 179 |
|
|---|
| 180 | <action> can be:
|
|---|
| 181 |
|
|---|
| 182 | =over 4
|
|---|
| 183 |
|
|---|
| 184 | =item B<sbx2build>
|
|---|
| 185 |
|
|---|
| 186 | Create tar files for the project under your CMS.
|
|---|
| 187 | Current state of the exported content is taken.
|
|---|
| 188 | CMS supported are SVN, SVK, CVS, Git and Mercurial
|
|---|
| 189 | parameters are packages to build
|
|---|
| 190 | if not using default list
|
|---|
| 191 |
|
|---|
| 192 | =item B<cms2build>
|
|---|
| 193 |
|
|---|
| 194 | Create tar files for the project under your CMS.
|
|---|
| 195 | Current state of the CMS is taken.
|
|---|
| 196 | CMS supported are SVN, SVK, CVS, Git and Mercurial
|
|---|
| 197 | parameters are packages to build
|
|---|
| 198 | if not using default list
|
|---|
| 199 |
|
|---|
| 200 | =item B<build2prep>
|
|---|
| 201 |
|
|---|
| 202 | Prepare the environment for build by installing required dependencies. Done once on the build system.
|
|---|
| 203 |
|
|---|
| 204 | =item B<build2pkg>
|
|---|
| 205 |
|
|---|
| 206 | Create packages for your running distribution
|
|---|
| 207 |
|
|---|
| 208 | =item B<cms2pkg>
|
|---|
| 209 |
|
|---|
| 210 | cms2build + build2pkg
|
|---|
| 211 |
|
|---|
| 212 | =item B<sbx2pkg>
|
|---|
| 213 |
|
|---|
| 214 | sbx2build + build2pkg
|
|---|
| 215 |
|
|---|
| 216 | =item B<sbx2pkg2ins>
|
|---|
| 217 |
|
|---|
| 218 | sbx2pkg + final install of packages
|
|---|
| 219 |
|
|---|
| 220 | =item B<build2ssh>
|
|---|
| 221 |
|
|---|
| 222 | Send the tar files to a SSH host
|
|---|
| 223 |
|
|---|
| 224 | =item B<sbx2ssh>
|
|---|
| 225 |
|
|---|
| 226 | sbx2build + build2ssh
|
|---|
| 227 |
|
|---|
| 228 | =item B<cms2ssh>
|
|---|
| 229 |
|
|---|
| 230 | cms2build + build2ssh
|
|---|
| 231 |
|
|---|
| 232 | =item B<pkg2ssh>
|
|---|
| 233 |
|
|---|
| 234 | Send the packages built to a SSH host
|
|---|
| 235 |
|
|---|
| 236 | =item B<build2vm>
|
|---|
| 237 |
|
|---|
| 238 | Create packages in VMs, launching them if needed
|
|---|
| 239 | and send those packages to a SSH host once built
|
|---|
| 240 | VM type supported are QEMU and KVM
|
|---|
| 241 |
|
|---|
| 242 | =item B<build2ve>
|
|---|
| 243 |
|
|---|
| 244 | Create packages in VEs, creating it if needed
|
|---|
| 245 | and send those packages to a SSH host once built
|
|---|
| 246 |
|
|---|
| 247 | =item B<build2rm>
|
|---|
| 248 |
|
|---|
| 249 | Create packages in RMs, which should pre-exist,
|
|---|
| 250 | and send those packages to a SSH host once built
|
|---|
| 251 | RM means Remote Machine, and could be a physical or Virtual one.
|
|---|
| 252 | This is one buildfarm integration for pb.
|
|---|
| 253 |
|
|---|
| 254 | =item B<prepvm>
|
|---|
| 255 |
|
|---|
| 256 | Prepare the VMs to have all requirements to build the project
|
|---|
| 257 |
|
|---|
| 258 | =item B<prepve>
|
|---|
| 259 |
|
|---|
| 260 | Prepare the VEs to have all requirements to build the project
|
|---|
| 261 |
|
|---|
| 262 | =item B<preprm>
|
|---|
| 263 |
|
|---|
| 264 | Prepare the RMs to have all requirements to build the project
|
|---|
| 265 |
|
|---|
| 266 | =item B<sbx2vm>
|
|---|
| 267 |
|
|---|
| 268 | sbx2build + build2vm
|
|---|
| 269 |
|
|---|
| 270 | =item B<sbx2ve>
|
|---|
| 271 |
|
|---|
| 272 | sbx2build + build2ve
|
|---|
| 273 |
|
|---|
| 274 | =item B<sbx2rm>
|
|---|
| 275 |
|
|---|
| 276 | sbx2build + build2rm
|
|---|
| 277 |
|
|---|
| 278 | =item B<cms2vm>
|
|---|
| 279 |
|
|---|
| 280 | cms2build + build2vm
|
|---|
| 281 |
|
|---|
| 282 | =item B<cms2ve>
|
|---|
| 283 |
|
|---|
| 284 | cms2build + build2ve
|
|---|
| 285 |
|
|---|
| 286 | =item B<cms2rm>
|
|---|
| 287 |
|
|---|
| 288 | cms2build + build2rm
|
|---|
| 289 |
|
|---|
| 290 | =item B<launchvm>
|
|---|
| 291 |
|
|---|
| 292 | Launch one virtual machine
|
|---|
| 293 |
|
|---|
| 294 | =item B<launchve>
|
|---|
| 295 |
|
|---|
| 296 | Launch one virtual environment
|
|---|
| 297 |
|
|---|
| 298 | =item B<script2vm>
|
|---|
| 299 |
|
|---|
| 300 | Launch one virtual machine if needed
|
|---|
| 301 | and executes a script on it
|
|---|
| 302 |
|
|---|
| 303 | =item B<script2ve>
|
|---|
| 304 |
|
|---|
| 305 | Execute a script in a virtual environment
|
|---|
| 306 |
|
|---|
| 307 | =item B<script2rm>
|
|---|
| 308 |
|
|---|
| 309 | Execute a script on a remote machine
|
|---|
| 310 |
|
|---|
| 311 | =item B<newvm>
|
|---|
| 312 |
|
|---|
| 313 | Create a new virtual machine
|
|---|
| 314 |
|
|---|
| 315 | =item B<newve>
|
|---|
| 316 |
|
|---|
| 317 | Create a new virtual environment
|
|---|
| 318 |
|
|---|
| 319 | =item B<setupvm>
|
|---|
| 320 |
|
|---|
| 321 | Setup a virtual machine for pb usage
|
|---|
| 322 |
|
|---|
| 323 | =item B<setupve>
|
|---|
| 324 |
|
|---|
| 325 | Setup a virtual environment for pb usage
|
|---|
| 326 |
|
|---|
| 327 | =item B<setuprm>
|
|---|
| 328 |
|
|---|
| 329 | Setup a remote machine for pb usage
|
|---|
| 330 |
|
|---|
| 331 | =item B<sbx2setupvm>
|
|---|
| 332 |
|
|---|
| 333 | Setup a virtual machine for pb usage using the sandbox version of pb instead of the latest stable
|
|---|
| 334 | Reserved to dev team.
|
|---|
| 335 |
|
|---|
| 336 | =item B<sbx2setupve>
|
|---|
| 337 |
|
|---|
| 338 | Setup a virtual environment for pb usage using the sandbox version of pb instead of the latest stable
|
|---|
| 339 | Reserved to dev team.
|
|---|
| 340 |
|
|---|
| 341 | =item B<sbx2setuprm>
|
|---|
| 342 |
|
|---|
| 343 | Setup a remote machine for pb usage using the sandbox version of pb instead of the latest stable
|
|---|
| 344 | Reserved to dev team.
|
|---|
| 345 |
|
|---|
| 346 | =item B<build2setupvm>
|
|---|
| 347 |
|
|---|
| 348 | Setup a virtual machine for pb usage using the build available
|
|---|
| 349 | Reserved to dev team.
|
|---|
| 350 |
|
|---|
| 351 | =item B<build2setupve>
|
|---|
| 352 |
|
|---|
| 353 | Setup a virtual environment for pb usage using the build available
|
|---|
| 354 | Reserved to dev team.
|
|---|
| 355 |
|
|---|
| 356 | =item B<build2setuprm>
|
|---|
| 357 |
|
|---|
| 358 | Setup a remote machine for pb usage using the build available
|
|---|
| 359 | Reserved to dev team.
|
|---|
| 360 |
|
|---|
| 361 | =item B<snapvm>
|
|---|
| 362 |
|
|---|
| 363 | Snapshot a virtual machine for pb usage
|
|---|
| 364 |
|
|---|
| 365 | =item B<snapve>
|
|---|
| 366 |
|
|---|
| 367 | Snapshot a virtual environment for pb usage
|
|---|
| 368 |
|
|---|
| 369 | =item B<updatevm>
|
|---|
| 370 |
|
|---|
| 371 | Update the distribution in the virtual machine
|
|---|
| 372 |
|
|---|
| 373 | =item B<updateve>
|
|---|
| 374 |
|
|---|
| 375 | Update the distribution in the virtual environment
|
|---|
| 376 |
|
|---|
| 377 | =item B<updaterm>
|
|---|
| 378 |
|
|---|
| 379 | Update the distribution in the remote machine
|
|---|
| 380 |
|
|---|
| 381 | =item B<test2pkg>
|
|---|
| 382 |
|
|---|
| 383 | Test a package locally
|
|---|
| 384 |
|
|---|
| 385 | =item B<test2vm>
|
|---|
| 386 |
|
|---|
| 387 | Test a package in a virtual machine
|
|---|
| 388 |
|
|---|
| 389 | =item B<test2ve>
|
|---|
| 390 |
|
|---|
| 391 | Test a package in a virtual environment
|
|---|
| 392 |
|
|---|
| 393 | =item B<test2rm>
|
|---|
| 394 |
|
|---|
| 395 | Test a package in a remote machine
|
|---|
| 396 |
|
|---|
| 397 | =item B<checkssh>
|
|---|
| 398 |
|
|---|
| 399 | Check the delivery of the packages on the repository
|
|---|
| 400 |
|
|---|
| 401 | =item B<checkps>
|
|---|
| 402 |
|
|---|
| 403 | Check the process running the VM concerned
|
|---|
| 404 |
|
|---|
| 405 | =item B<newver>
|
|---|
| 406 |
|
|---|
| 407 | Create a new version of the project derived
|
|---|
| 408 | from the current one
|
|---|
| 409 |
|
|---|
| 410 | =item B<newproj>
|
|---|
| 411 |
|
|---|
| 412 | Create a new project and a template set of
|
|---|
| 413 | configuration files under pbconf
|
|---|
| 414 |
|
|---|
| 415 | =item B<announce>
|
|---|
| 416 |
|
|---|
| 417 | Announce the availability of the project through various means
|
|---|
| 418 |
|
|---|
| 419 | =item B<sbx2webssh>
|
|---|
| 420 |
|
|---|
| 421 | Create tar files for the website under your CMS.
|
|---|
| 422 | Current state of the exported content is taken.
|
|---|
| 423 | Deliver the content to the target server using ssh from the exported dir.
|
|---|
| 424 |
|
|---|
| 425 | =item B<cms2webssh>
|
|---|
| 426 |
|
|---|
| 427 | Create tar files for the website from your CMS.
|
|---|
| 428 | Deliver the content to the target server using ssh from the DVCS.
|
|---|
| 429 |
|
|---|
| 430 | =item B<sbx2webpkg>
|
|---|
| 431 |
|
|---|
| 432 | Create tar files for the website under your CMS.
|
|---|
| 433 | Current state of the exported content is taken.
|
|---|
| 434 |
|
|---|
| 435 | =item B<cms2webpkg>
|
|---|
| 436 |
|
|---|
| 437 | Create tar files for the website under your CMS.
|
|---|
| 438 |
|
|---|
| 439 | =item B<getconf>
|
|---|
| 440 |
|
|---|
| 441 | Print the full configuration parameters as found in the various configuration files. Help to debug conf issues.
|
|---|
| 442 | Also accepts a parameter to display only this value, and a VM/VE/RM
|
|---|
| 443 |
|
|---|
| 444 | =item B<clean>
|
|---|
| 445 |
|
|---|
| 446 | Purge the build and delivery directories related to the current project
|
|---|
| 447 |
|
|---|
| 448 | =item B<cleanssh>
|
|---|
| 449 |
|
|---|
| 450 | Purge the ssh server of its packages (only for testver and test packages)
|
|---|
| 451 |
|
|---|
| 452 | =back
|
|---|
| 453 |
|
|---|
| 454 | <pkgs> can be a list of packages, the keyword 'all' or nothing, in which case the default list of packages is taken (corresponding to the defpkgdir list of arguments in the configuration file).
|
|---|
| 455 |
|
|---|
| 456 | =head1 WEB SITES
|
|---|
| 457 |
|
|---|
| 458 | The main Web site of the project is available at L<http://www.project-builder.org/>. Bug reports should be filled using the trac instance of the project at L<http://trac.project-builder.org/>.
|
|---|
| 459 |
|
|---|
| 460 | =head1 USER MAILING LIST
|
|---|
| 461 |
|
|---|
| 462 | None exists for the moment.
|
|---|
| 463 |
|
|---|
| 464 | =head1 ENVIRONMENT VARIABLES
|
|---|
| 465 |
|
|---|
| 466 | =item B<PBACCOUNT>
|
|---|
| 467 |
|
|---|
| 468 | Login to use to connect to the VM/RM, undef by default
|
|---|
| 469 |
|
|---|
| 470 | =back
|
|---|
| 471 |
|
|---|
| 472 | =head1 CONFIGURATION FILES
|
|---|
| 473 |
|
|---|
| 474 | Each pb user may have a configuration in F<$HOME/.pbrc>. The values in this file may overwrite any other configuration file value.
|
|---|
| 475 |
|
|---|
| 476 | Here is an example of such a configuration file:
|
|---|
| 477 |
|
|---|
| 478 | #
|
|---|
| 479 | # Define for each project the URL of its pbconf repository
|
|---|
| 480 | # No default option allowed here as they need to be all different
|
|---|
| 481 | #
|
|---|
| 482 | # URL of the pbconf content
|
|---|
| 483 | # This is the format of a classical URL with the extension of additional schema such as
|
|---|
| 484 | # svn+ssh, cvs+ssh, ...
|
|---|
| 485 | #
|
|---|
| 486 | pbconfurl linuxcoe = cvs+ssh://:ext:bcornec@linuxcoe.cvs.sourceforge.net:/cvsroot/linuxcoe/pbconf
|
|---|
| 487 |
|
|---|
| 488 | # This is normaly defined in the project's configuration file
|
|---|
| 489 | # Url of the project
|
|---|
| 490 | #
|
|---|
| 491 | pburl linuxcoe = cvs+ssh://:ext:bcornec@linuxcoe.cvs.sourceforge.net:/cvsroot/linuxcoe
|
|---|
| 492 |
|
|---|
| 493 | # All these URLs needs to be defined here as the are the entry point
|
|---|
| 494 | # for how to build packages for the project
|
|---|
| 495 | #
|
|---|
| 496 | pbconfurl pb = svn+ssh://svn.project-builder.org/mondo/svn/pb/pbconf
|
|---|
| 497 | pbconfurl mondorescue = svn+ssh://svn.project-builder.org/mondo/svn/project-builder/mondorescue/pbconf
|
|---|
| 498 | pbconfurl collectl = svn+ssh://bruno@svn.mondorescue.org/mondo/svn/project-builder/collectl/pbconf
|
|---|
| 499 | pbconfurl netperf = svn+ssh://svn.mondorescue.org/mondo/svn/project-builder/netperf/pbconf
|
|---|
| 500 |
|
|---|
| 501 | # Under that dir will take place everything related to pb
|
|---|
| 502 | # If you want to use VMs/chroot/..., then use $ENV{'HOME'} to make it portable
|
|---|
| 503 | # to your VMs/chroot/...
|
|---|
| 504 | # if not defined then /var/cache
|
|---|
| 505 | pbdefdir default = $ENV{'HOME'}/project-builder
|
|---|
| 506 | pbdefdir pb = $ENV{'HOME'}
|
|---|
| 507 | pbdefdir linuxcoe = $ENV{'HOME'}/LinuxCOE/cvs
|
|---|
| 508 | pbdefdir mondorescue = $ENV{'HOME'}/mondo/svn
|
|---|
| 509 |
|
|---|
| 510 | # pbconfdir points to the directory where the CMS content of the pbconfurl is checked out
|
|---|
| 511 | # If not defined, pbconfdir is under pbdefdir/pbproj/pbconf
|
|---|
| 512 | pbconfdir linuxcoe = $ENV{'HOME'}/LinuxCOE/cvs/pbconf
|
|---|
| 513 | pbconfdir mondorescue = $ENV{'HOME'}/mondo/svn/pbconf
|
|---|
| 514 |
|
|---|
| 515 | # pbdir points to the directory where the CMS content of the pburl is checked out
|
|---|
| 516 | # If not defined, pbdir is under pbdefdir/pbproj
|
|---|
| 517 | # Only defined if we have access to the dev of the project
|
|---|
| 518 | pbdir linuxcoe = $ENV{'HOME'}/LinuxCOE/cvs
|
|---|
| 519 | pbdir mondorescue = $ENV{'HOME'}/mondo/svn
|
|---|
| 520 |
|
|---|
| 521 | # -daemonize doesn't work with qemu 0.8.2
|
|---|
| 522 | vmopt default = -m 384
|
|---|
| 523 |
|
|---|
| 524 | =head1 COMMAND DETAILS
|
|---|
| 525 |
|
|---|
| 526 | =head2 newproj
|
|---|
| 527 |
|
|---|
| 528 | The newproj command creates a new project-builder project. To run this command you first need to define two variables in your ~/.pbrc file:
|
|---|
| 529 |
|
|---|
| 530 | pbconfurl I<project> = file:///home/anderse/.git/project-builder-config/I<project>
|
|---|
| 531 | pbdefdir default = $ENV{HOME}/cache-project-builder
|
|---|
| 532 |
|
|---|
| 533 | The first line defines the version controlled configuration information and the second defines the root directory for project-builder to use.
|
|---|
| 534 |
|
|---|
| 535 | You can then run the command:
|
|---|
| 536 |
|
|---|
| 537 | % pb -p I<$project> -r I<$version> newproj I<$pkg>
|
|---|
| 538 |
|
|---|
| 539 | to create the new project. Running the newproj command will then generate the file $pbdefdir/$project/pbconf/$version/$project.pb, and the directory $pbdefdir/$project/pbconf/$version/$pkg. You will need to edit those files to make the later commands work.
|
|---|
| 540 |
|
|---|
| 541 | =head2 cms2build
|
|---|
| 542 |
|
|---|
| 543 | The cms2build command takes your files from the content management system and makes the two tar files that are necessary for building files. You need to have run the newproj command first. Then there are several steps for running this command:
|
|---|
| 544 |
|
|---|
| 545 | =over 4
|
|---|
| 546 |
|
|---|
| 547 | =item Update your $project.pb configuration file.
|
|---|
| 548 |
|
|---|
| 549 | You need to set the pburl, pbrepo, pbwf, pbpackager, projver, projtag, testver, delivery, and defpkgdir lines as described in the configuration file. The pburl entry is used to find the source for your package. The pbrepo entry is used to build the .repo or .sources.list files for use by downloaders of the package. The pbwf entry indicates that the source tar file is named by I<package-name>-I<version>. The pbpackager entry will be stored in the packages and should be you or your team. The projver/projtag entries indicate the version of the software and the version of the packaging scripts. The testver entry when true indicates that the package is in a test version, so no log file is computed (can be long), and version is made up using a timstamp. The delivery entry gives the subdirectory under which the packages will be delivered on the repository, and the defpkgdir entry corresponds to the local subdirectory hosting the package content.
|
|---|
| 550 |
|
|---|
| 551 | For example:
|
|---|
| 552 |
|
|---|
| 553 | pburl Lintel = file:///home/anderse/projects/Lintel-0.2012.02.28.tar.gz
|
|---|
| 554 | pbrepo Lintel = http://tesla.hpl.hp.com/opensource
|
|---|
| 555 | pbwf Lintel = 1
|
|---|
| 556 | pbpackager Lintel = Eric Anderson <eric.anderson4@hp.com>
|
|---|
| 557 | projver Lintel = 0.2012.02.28
|
|---|
| 558 | projtag Lintel = 1
|
|---|
| 559 | testver Lintel = false
|
|---|
| 560 | delivery Lintel = production
|
|---|
| 561 | defpkgdir Lintel = Lintel-0.2012.02.28
|
|---|
| 562 |
|
|---|
| 563 | =item Create the build .tar.gz files:
|
|---|
| 564 |
|
|---|
| 565 | Then you need to take those files and create the initial tar files. Run a command like:
|
|---|
| 566 |
|
|---|
| 567 | % pb -p $project -r $version cms2build
|
|---|
| 568 |
|
|---|
| 569 | To create the $pbdefdir/$project/pbdelivery/$project-$version.{,pbconf}.tar.gz files, the $version-$projtag.pb and pbrc files in the same directory.
|
|---|
| 570 |
|
|---|
| 571 | =back
|
|---|
| 572 |
|
|---|
| 573 | =head2 build2pkg
|
|---|
| 574 |
|
|---|
| 575 | The build2pkg command takes the tar files created in the cms2build step and attempts to build binary packages for your current operating system. There are two steps:
|
|---|
| 576 |
|
|---|
| 577 | =over 4
|
|---|
| 578 |
|
|---|
| 579 | =item Update your filters and build files.
|
|---|
| 580 |
|
|---|
| 581 | You probably need to edit the files describing the build steps in one of the $pbdefdir/$project/pbconf/$version/$project/{deb,rpm,pkg} directories and the filters in $pbdefdir/$project/pbconf/$version/pbfilter. Note that you can define additional filters and transforms in the *.pbf files. The build files will be filtered by the filters defined in the *.pbf files to generate the inputs to the build step. Therefore, if you change those files, you need to re-run the cms2build step.
|
|---|
| 582 |
|
|---|
| 583 | =item Build the package.
|
|---|
| 584 |
|
|---|
| 585 | Then you can run a command like:
|
|---|
| 586 |
|
|---|
| 587 | % pb -p $project -r $version build2pkg
|
|---|
| 588 |
|
|---|
| 589 | To create the files in $project/pbbuild that comprise your binary package(s).
|
|---|
| 590 |
|
|---|
| 591 | =back
|
|---|
| 592 |
|
|---|
| 593 | =head2 newve
|
|---|
| 594 |
|
|---|
| 595 | The newve command creates a new virtual environment, i.e. a chrooted OS for building packages. Using a virtual environment is an efficient way to build packages on a related set of operating systems. The OS's have to be related because the kernel will be shared. Steps:
|
|---|
| 596 |
|
|---|
| 597 | =over 4
|
|---|
| 598 |
|
|---|
| 599 | =item Update ~/.pbrc
|
|---|
| 600 |
|
|---|
| 601 | Update your ~/.pbrc file to specify the vepath, velist, velogin, and vetype variables, e.g.:
|
|---|
| 602 |
|
|---|
| 603 | vepath default = $ENV{HOME}/cache-project-builder/chroot
|
|---|
| 604 | velist default = debian-6.0-i386
|
|---|
| 605 | velogin default = pb
|
|---|
| 606 | vetype default = chroot
|
|---|
| 607 |
|
|---|
| 608 | If you are building for rpm style OS's, update the verpmtype option, and install the appropriate tool.
|
|---|
| 609 |
|
|---|
| 610 | verpmtype default = rpmbootstrap
|
|---|
| 611 |
|
|---|
| 612 | You may also choose to specify a mirror for the OS packages, and optionally http/ftp proxies. You can specify the proxies either through environment variables ($http_proxy/$ftp_proxy) or in the configuration file. The configuration file will be used if no corresponding environment variable has been set. For example, for debian and with a local squid proxy:
|
|---|
| 613 |
|
|---|
| 614 | rbsmirrorsrv debian = http://mirrors1.kernel.org/debian/
|
|---|
| 615 | http_proxy default = http://localhost:3128/
|
|---|
| 616 | ftp_proxy default = http://localhost:3128/
|
|---|
| 617 |
|
|---|
| 618 | =item Run the cms2build command
|
|---|
| 619 |
|
|---|
| 620 | If you have deleted your $package/pbdelivery directory, re-run the cms2build command as in the earlier step. This step is necessary to generate the I<package>/pbdelivery/pbrc file.
|
|---|
| 621 |
|
|---|
| 622 | =item Create the new virtual environment
|
|---|
| 623 |
|
|---|
| 624 | Initialize the new operating system. This step will install the core OS packages for the virtual environment, e.g.:
|
|---|
| 625 |
|
|---|
| 626 | % pb -v -p $project -m debian-6.0-i386 newve
|
|---|
| 627 |
|
|---|
| 628 | =back
|
|---|
| 629 |
|
|---|
| 630 | =head2 setupve
|
|---|
| 631 |
|
|---|
| 632 | The setupve command prepares a virtual environment for use by project builder. In particular it installs project-builder from the packages into the virtual environment. Two sub-steps are necessary:
|
|---|
| 633 |
|
|---|
| 634 | =over 4
|
|---|
| 635 |
|
|---|
| 636 | =item Update $project.pb
|
|---|
| 637 |
|
|---|
| 638 | You need to have a sshhost entry for setupve to work, so add one, even an invalid one, e.g.:
|
|---|
| 639 |
|
|---|
| 640 | sshhost $project = foo.example.org
|
|---|
| 641 |
|
|---|
| 642 | =item Setup the virtual environment
|
|---|
| 643 |
|
|---|
| 644 | % pb -v -p $project -m debian-6.0-i386 setupve
|
|---|
| 645 |
|
|---|
| 646 | If you prefer to install the current SVN version of project builder, you can substitute the setupve option by the sbx2setupv one.
|
|---|
| 647 |
|
|---|
| 648 | =back
|
|---|
| 649 |
|
|---|
| 650 | =head2 build2ve
|
|---|
| 651 |
|
|---|
| 652 | The build2ve command is similar to the build2pkg command in that it will take the sources created by cms2build and turn them into binary packages. The command has two differences. First, it creates the packages in a virtual environment, i.e. the one made by an earlier setupve setup. Second it copies the resulting packages to a repository and builds the repository meta-data needed.
|
|---|
| 653 |
|
|---|
| 654 | Three sub-steps are needed:
|
|---|
| 655 |
|
|---|
| 656 | =over 4
|
|---|
| 657 |
|
|---|
| 658 | =item Update $project.pb
|
|---|
| 659 |
|
|---|
| 660 | You need to have a valid sshdir and sshhost entry for build2ve to work, so add them. Note that you need to be able to ssh from the host you run the command on to the repository host, preferably without needing to type in a password, so using ssh-agent or having a special passwordless project-builder ssh key will make this step easier.
|
|---|
| 661 |
|
|---|
| 662 | sshhost $project = localhost
|
|---|
| 663 | sshdir $project = $home/cache-project-builder/repos
|
|---|
| 664 |
|
|---|
| 665 | You may also need to specify additional repository files to use or rpms to install. Note the URL for repositories is not the URL of the repository, but the URL of a file that can be put in the yum.repos.d or apt.sources.d directory.
|
|---|
| 666 |
|
|---|
| 667 | addrepo centos-5-i386 = http://localhost/pb/centos-extras.repo,http://mirror.centos.org/centos/5/extras/i386/RPMS/chrpath-0.13-3.el5.centos.i386.rpm
|
|---|
| 668 |
|
|---|
| 669 | =item Update your filters and build files
|
|---|
| 670 |
|
|---|
| 671 | You may need to update your filter files (*.pbf) as in the build2pkg step if you are building for a new OS or architecture.
|
|---|
| 672 |
|
|---|
| 673 | =item Build the packages and copy them to the repository
|
|---|
| 674 |
|
|---|
| 675 | % pb -v -p $project -m debian-6.0-i386 build2ve
|
|---|
| 676 |
|
|---|
| 677 | =back
|
|---|
| 678 |
|
|---|
| 679 | *Debugging:* If the build fails (and you did not specify the --no-stop-on-error) option, then the virtual environment and scripts should still be present and configured to build the package. You can run a command like 'sudo setarch i386 chroot $path bash' in order to get into the environment. In your log you should see a command like that. From there you can go into the /home/pb directory as the pb user and run the same style of pb commands as you did when doing build2pkg. This will help you figure out what has gone wrong in the build in the virtual environment.
|
|---|
| 680 |
|
|---|
| 681 | =head1 AUTHORS
|
|---|
| 682 |
|
|---|
| 683 | The Project-Builder.org team L<http://trac.project-builder.org/> lead by Bruno Cornec L<mailto:bruno@project-builder.org>.
|
|---|
| 684 |
|
|---|
| 685 | =head1 COPYRIGHT
|
|---|
| 686 |
|
|---|
| 687 | Project-Builder.org is distributed under the GPL v2.0 license
|
|---|
| 688 | described in the file C<COPYING> included with the distribution.
|
|---|
| 689 |
|
|---|
| 690 | =cut
|
|---|
| 691 |
|
|---|
| 692 | # ---------------------------------------------------------------------------
|
|---|
| 693 |
|
|---|
| 694 | my ($projectbuilderver,$projectbuilderrev) = pb_version_init();
|
|---|
| 695 | my $appname = "pb";
|
|---|
| 696 |
|
|---|
| 697 | # Initialize the syntax string
|
|---|
| 698 |
|
|---|
| 699 | pb_syntax_init("$appname (aka project-builder.org) Version $projectbuilderver-$projectbuilderrev\n");
|
|---|
| 700 |
|
|---|
| 701 | GetOptions("help|?|h+" => \$opts{'h'},
|
|---|
| 702 | "account|a=s" => \$opts{'a'},
|
|---|
| 703 | "force|f" => \$opts{'f'},
|
|---|
| 704 | "nographic|g" => \$opts{'g'},
|
|---|
| 705 | "image|i=s" => \$opts{'i'},
|
|---|
| 706 | "log-files|l=s" => \$opts{'l'},
|
|---|
| 707 | "machines|mock|m=s" => \$opts{'m'},
|
|---|
| 708 | "man" => \$opts{'man'},
|
|---|
| 709 | "port|P=i" => \$opts{'P'},
|
|---|
| 710 | "project|p=s" => \$opts{'p'},
|
|---|
| 711 | "quiet|q" => \$opts{'q'},
|
|---|
| 712 | "revision|r=s" => \$opts{'r'},
|
|---|
| 713 | "rebuild" => \$opts{'rebuild'},
|
|---|
| 714 | "snapshot|S" => \$opts{'S'},
|
|---|
| 715 | "script|s=s" => \$opts{'s'},
|
|---|
| 716 | "type|T:s" => \$opts{'T'},
|
|---|
| 717 | "target|t:s" => \$opts{'t'},
|
|---|
| 718 | "version|V=s" => \$opts{'V'},
|
|---|
| 719 | "verbose|v+" => \$opts{'v'},
|
|---|
| 720 | "keep|k" => \$opts{'k'},
|
|---|
| 721 | "stop-on-error!" => \$Global::pb_stop_on_error,
|
|---|
| 722 | ) || pb_syntax(-1,0);
|
|---|
| 723 |
|
|---|
| 724 | if (defined $opts{'l'}) {
|
|---|
| 725 | open(pbLOG,"> $opts{'l'}") || die "Unable to log to $opts{'l'}: $!";
|
|---|
| 726 | $pbLOG = \*pbLOG;
|
|---|
| 727 | $pbdebug = 0 if ($pbdebug == -1);
|
|---|
| 728 | }
|
|---|
| 729 | pb_log_init($pbdebug, $pbLOG);
|
|---|
| 730 |
|
|---|
| 731 | if (defined $opts{'h'}) {
|
|---|
| 732 | pb_syntax(0,$opts{'h'}-1);
|
|---|
| 733 | }
|
|---|
| 734 | if (defined $opts{'man'}) {
|
|---|
| 735 | pb_syntax(0,2);
|
|---|
| 736 | }
|
|---|
| 737 | if (defined $opts{'v'}) {
|
|---|
| 738 | $pbdebug = $opts{'v'};
|
|---|
| 739 | }
|
|---|
| 740 | if (defined $opts{'f'}) {
|
|---|
| 741 | $pbforce=1;
|
|---|
| 742 | }
|
|---|
| 743 | if (defined $opts{'q'}) {
|
|---|
| 744 | $pbdebug=-1;
|
|---|
| 745 | }
|
|---|
| 746 | if (defined $opts{'S'}) {
|
|---|
| 747 | $pbsnap=1;
|
|---|
| 748 | }
|
|---|
| 749 | if (defined $opts{'k'}) {
|
|---|
| 750 | $pbkeep=1;
|
|---|
| 751 | }
|
|---|
| 752 | pb_display_init("text","");
|
|---|
| 753 |
|
|---|
| 754 | # Handle root of the project if defined
|
|---|
| 755 | if (defined $opts{'r'}) {
|
|---|
| 756 | $ENV{'PBROOTDIR'} = $opts{'r'};
|
|---|
| 757 | }
|
|---|
| 758 | # Handle virtual machines if any
|
|---|
| 759 | if (defined $opts{'m'}) {
|
|---|
| 760 | $ENV{'PBV'} = $opts{'m'};
|
|---|
| 761 | }
|
|---|
| 762 | if (defined $opts{'s'}) {
|
|---|
| 763 | $pbscript{'default'} = $opts{'s'};
|
|---|
| 764 | die "option -s requires a script having a full path name" if ($pbscript{'default'} !~ /^\//);
|
|---|
| 765 | }
|
|---|
| 766 | if (defined $opts{'a'}) {
|
|---|
| 767 | $ENV{'PBACCOUNT'} = $opts{'a'};
|
|---|
| 768 | die "option -a requires a -s script option" if (not defined $pbscript{'default'});
|
|---|
| 769 | }
|
|---|
| 770 | if (defined $opts{'P'}) {
|
|---|
| 771 | $pbport = $opts{'P'};
|
|---|
| 772 | }
|
|---|
| 773 | if (defined $opts{'V'}) {
|
|---|
| 774 | $newver = $opts{'V'};
|
|---|
| 775 | }
|
|---|
| 776 | if (defined $opts{'i'}) {
|
|---|
| 777 | $pbimage = $opts{'i'};
|
|---|
| 778 | }
|
|---|
| 779 | if (defined $opts{'t'}) {
|
|---|
| 780 | $pbtarget = $opts{'t'};
|
|---|
| 781 | }
|
|---|
| 782 | if (defined $opts{'T'}) {
|
|---|
| 783 | $vetype = $opts{'T'};
|
|---|
| 784 | }
|
|---|
| 785 |
|
|---|
| 786 | # Get Action
|
|---|
| 787 | $action = shift @ARGV;
|
|---|
| 788 | die pb_syntax(-1,1) if (not defined $action);
|
|---|
| 789 |
|
|---|
| 790 | my ($filteredfiles, $supfiles, $defpkgdir, $extpkgdir);
|
|---|
| 791 | my $pbinit = undef;
|
|---|
| 792 | $pbinit = 1 if ($action =~ /^newproj$/);
|
|---|
| 793 |
|
|---|
| 794 | # Handles project name if any
|
|---|
| 795 | # And get global params
|
|---|
| 796 | ($filteredfiles, $supfiles, $defpkgdir, $extpkgdir) = pb_env_init($opts{'p'},$pbinit,$action,$pbkeep);
|
|---|
| 797 |
|
|---|
| 798 | #
|
|---|
| 799 | # Check for command requirements
|
|---|
| 800 | #
|
|---|
| 801 | my ($req,$opt,$pbpara,$pbshowsudo,$pbstoponerr) = pb_conf_get_if("oscmd","oscmdopt","pbparallel","pbshowsudo","pbstoponerr");
|
|---|
| 802 | pb_check_requirements($req,$opt,$appname);
|
|---|
| 803 |
|
|---|
| 804 | $Global::pb_show_sudo = 1 if ((defined $pbshowsudo) && (defined $pbshowsudo->{$ENV{'PBPROJ'}}) && ($pbshowsudo->{$ENV{'PBPROJ'}} =~ /true/oi));
|
|---|
| 805 | $Global::pb_stop_on_error = 1 if ((defined $pbstoponerr) && (defined $pbstoponerr->{$ENV{'PBPROJ'}}) && ($pbstoponerr->{$ENV{'PBPROJ'}} =~ /true/oi));
|
|---|
| 806 |
|
|---|
| 807 | #
|
|---|
| 808 | # Check if we can launch some actions in // with Parallel::ForkManager
|
|---|
| 809 | #
|
|---|
| 810 | my $pbparallel = $pbpara->{$appname} if (defined $pbpara);
|
|---|
| 811 | if (not defined $pbparallel) {
|
|---|
| 812 | eval
|
|---|
| 813 | {
|
|---|
| 814 | require Sys::CPU;
|
|---|
| 815 | Sys::CPU->import();
|
|---|
| 816 | };
|
|---|
| 817 | if ($@) {
|
|---|
| 818 | # Sys::CPU not found, defaulting to 1
|
|---|
| 819 | pb_log(1,"ADVISE: Install Sys::CPU to benefit from automatic parallelism optimization.\nOr use pbparallel in your pb.conf file\nOnly 1 process at a time for the moment\n");
|
|---|
| 820 | $pbparallel = 1;
|
|---|
| 821 | } else {
|
|---|
| 822 | # Using the number of cores
|
|---|
| 823 | $pbparallel = Sys::CPU::cpu_count();
|
|---|
| 824 | pb_log(1,"Using parallel mode with $pbparallel processes\n");
|
|---|
| 825 | }
|
|---|
| 826 | }
|
|---|
| 827 |
|
|---|
| 828 | eval
|
|---|
| 829 | {
|
|---|
| 830 | require Parallel::ForkManager;
|
|---|
| 831 | Parallel::ForkManager->import();
|
|---|
| 832 | };
|
|---|
| 833 | # Parallel::ForkManager not found so no // actions
|
|---|
| 834 | if ($@) {
|
|---|
| 835 | $pbparallel = undef;
|
|---|
| 836 | pb_log(1,"ADVISE: Install Parallel::ForkManager to benefit from automatic parallelism optimization.\nOnly 1 process at a time for the moment\n");
|
|---|
| 837 | }
|
|---|
| 838 |
|
|---|
| 839 | pb_log(0,"Project: $ENV{'PBPROJ'}\n");
|
|---|
| 840 | pb_log(0,"Action: $action\n");
|
|---|
| 841 |
|
|---|
| 842 | my $do_install = undef;
|
|---|
| 843 | # Possibility to add a 2ins to some commands to launch automatic installation
|
|---|
| 844 | $do_install = 1 if ($action =~ /2ins$/);
|
|---|
| 845 |
|
|---|
| 846 | # Act depending on action
|
|---|
| 847 | if ($action =~ /^cms2build$/) {
|
|---|
| 848 | pb_cms2build("CMS");
|
|---|
| 849 | } elsif ($action =~ /^sbx2build$/) {
|
|---|
| 850 | pb_cms2build("SandBox");
|
|---|
| 851 | } elsif ($action =~ /^build2prep/) {
|
|---|
| 852 | pb_build2prep();
|
|---|
| 853 | } elsif ($action =~ /^build2pkg/) {
|
|---|
| 854 | pb_build2pkg($do_install);
|
|---|
| 855 | } elsif ($action =~ /^cms2pkg/) {
|
|---|
| 856 | pb_cms2build("CMS");
|
|---|
| 857 | pb_build2pkg($do_install);
|
|---|
| 858 | } elsif ($action =~ /^sbx2pkg/) {
|
|---|
| 859 | pb_cms2build("SandBox");
|
|---|
| 860 | pb_build2pkg($do_install);
|
|---|
| 861 | } elsif ($action =~ /^build2ssh$/) {
|
|---|
| 862 | pb_build2ssh();
|
|---|
| 863 | } elsif ($action =~ /^cms2ssh$/) {
|
|---|
| 864 | pb_cms2build("CMS");
|
|---|
| 865 | pb_build2ssh();
|
|---|
| 866 | } elsif ($action =~ /^sbx2ssh$/) {
|
|---|
| 867 | pb_cms2build("SandBox");
|
|---|
| 868 | pb_build2ssh();
|
|---|
| 869 | } elsif ($action =~ /^pkg2ssh$/) {
|
|---|
| 870 | pb_pkg2ssh();
|
|---|
| 871 | } elsif ($action =~ /^build2rm$/) {
|
|---|
| 872 | pb_build2v("rm","build");
|
|---|
| 873 | } elsif ($action =~ /^build2ve$/) {
|
|---|
| 874 | pb_build2v("ve","build");
|
|---|
| 875 | } elsif ($action =~ /^build2vm$/) {
|
|---|
| 876 | pb_build2v("vm","build");
|
|---|
| 877 | } elsif ($action =~ /^sbx2preprm$/) {
|
|---|
| 878 | pb_cms2build("SandBox");
|
|---|
| 879 | pb_build2v("rm","prep");
|
|---|
| 880 | } elsif ($action =~ /^sbx2prepve$/) {
|
|---|
| 881 | pb_cms2build("SandBox");
|
|---|
| 882 | pb_build2v("ve","prep");
|
|---|
| 883 | } elsif ($action =~ /^sbx2prepvm$/) {
|
|---|
| 884 | pb_cms2build("SandBox");
|
|---|
| 885 | pb_build2v("vm","prep");
|
|---|
| 886 | } elsif ($action =~ /^preprm$/) {
|
|---|
| 887 | pb_build2v("rm","prep");
|
|---|
| 888 | } elsif ($action =~ /^prepve$/) {
|
|---|
| 889 | pb_build2v("ve","prep");
|
|---|
| 890 | } elsif ($action =~ /^prepvm$/) {
|
|---|
| 891 | pb_build2v("vm","prep");
|
|---|
| 892 | } elsif ($action =~ /^cms2rm$/) {
|
|---|
| 893 | pb_cms2build("CMS");
|
|---|
| 894 | pb_build2v("rm","build");
|
|---|
| 895 | } elsif ($action =~ /^cms2ve$/) {
|
|---|
| 896 | pb_cms2build("CMS");
|
|---|
| 897 | pb_build2v("ve","build");
|
|---|
| 898 | } elsif ($action =~ /^sbx2rm$/) {
|
|---|
| 899 | pb_cms2build("SandBox");
|
|---|
| 900 | pb_build2v("rm","build");
|
|---|
| 901 | } elsif ($action =~ /^sbx2ve$/) {
|
|---|
| 902 | pb_cms2build("SandBox");
|
|---|
| 903 | pb_build2v("ve","build");
|
|---|
| 904 | } elsif ($action =~ /^cms2vm$/) {
|
|---|
| 905 | pb_cms2build("CMS");
|
|---|
| 906 | pb_build2v("vm","build");
|
|---|
| 907 | } elsif ($action =~ /^sbx2vm$/) {
|
|---|
| 908 | pb_cms2build("SandBox");
|
|---|
| 909 | pb_build2v("vm","build");
|
|---|
| 910 | } elsif ($action =~ /^launchvm$/) {
|
|---|
| 911 | pb_parallel_launchv(undef,"vm",undef,3,$pbimage);
|
|---|
| 912 | } elsif ($action =~ /^launchve$/) {
|
|---|
| 913 | pb_parallel_launchv(undef,"ve",undef,3,$pbimage);
|
|---|
| 914 | } elsif ($action =~ /^script2vm$/) {
|
|---|
| 915 | die "action script2vm requires a -s script option" if (not defined $pbscript{'default'});
|
|---|
| 916 | pb_script2v(\%pbscript,"vm");
|
|---|
| 917 | } elsif ($action =~ /^script2ve$/) {
|
|---|
| 918 | die "action script2ve requires a -s script option" if (not defined $pbscript{'default'});
|
|---|
| 919 | pb_script2v(\%pbscript,"ve");
|
|---|
| 920 | } elsif ($action =~ /^script2rm$/) {
|
|---|
| 921 | die "action script2rm requires a -s script option" if (not defined $pbscript{'default'});
|
|---|
| 922 | pb_script2v(\%pbscript,"rm");
|
|---|
| 923 | } elsif ($action =~ /^newver$/) {
|
|---|
| 924 | pb_newver();
|
|---|
| 925 | } elsif ($action =~ /^newve$/) {
|
|---|
| 926 | pb_parallel_launchv(undef,"ve",undef,0,$pbimage);
|
|---|
| 927 | } elsif ($action =~ /^newvm$/) {
|
|---|
| 928 | pb_parallel_launchv(undef,"vm",undef,0,$pbimage);
|
|---|
| 929 | pb_log(0, "Please ensure that sshd is running in your VM by default\n");
|
|---|
| 930 | pb_log(0, "and that it allows remote root login (PermitRootLogin yes in /etc/ssh/sshd_config)\n");
|
|---|
| 931 | pb_log(0, "Also ensure that network is up, firewalling correctly configured\n");
|
|---|
| 932 | pb_log(0, "and perl, Data::Dumper, tar, sudo, ntpdate and scp/ssh installed\n");
|
|---|
| 933 | pb_log(0, "You should then be able to login with ssh -p VMPORT root\@localhost (if VM started with pb)\n");
|
|---|
| 934 | } elsif ($action =~ /^setuprm$/) {
|
|---|
| 935 | pb_setup2v("rm");
|
|---|
| 936 | } elsif ($action =~ /^setupve$/) {
|
|---|
| 937 | pb_setup2v("ve");
|
|---|
| 938 | } elsif ($action =~ /^setupvm$/) {
|
|---|
| 939 | pb_setup2v("vm");
|
|---|
| 940 | } elsif ($action =~ /^sbx2setuprm$/) {
|
|---|
| 941 | die "This feature is limited to the pb project" if ($ENV{'PBPROJ'} ne $appname);
|
|---|
| 942 | pb_cms2build("SandBox");
|
|---|
| 943 | pb_setup2v("rm","SandBox");
|
|---|
| 944 | } elsif ($action =~ /^sbx2setupve$/) {
|
|---|
| 945 | die "This feature is limited to the pb project" if ($ENV{'PBPROJ'} ne $appname);
|
|---|
| 946 | pb_cms2build("SandBox");
|
|---|
| 947 | pb_setup2v("ve","SandBox");
|
|---|
| 948 | } elsif ($action =~ /^sbx2setupvm$/) {
|
|---|
| 949 | die "This feature is limited to the pb project" if ($ENV{'PBPROJ'} ne $appname);
|
|---|
| 950 | pb_cms2build("SandBox");
|
|---|
| 951 | pb_setup2v("vm","SandBox");
|
|---|
| 952 | } elsif ($action =~ /^build2setuprm$/) {
|
|---|
| 953 | die "This feature is limited to the pb project" if ($ENV{'PBPROJ'} ne $appname);
|
|---|
| 954 | pb_setup2v("rm","SandBox");
|
|---|
| 955 | } elsif ($action =~ /^build2setupve$/) {
|
|---|
| 956 | die "This feature is limited to the pb project" if ($ENV{'PBPROJ'} ne $appname);
|
|---|
| 957 | pb_setup2v("ve","SandBox");
|
|---|
| 958 | } elsif ($action =~ /^build2setupvm$/) {
|
|---|
| 959 | die "This feature is limited to the pb project" if ($ENV{'PBPROJ'} ne $appname);
|
|---|
| 960 | pb_setup2v("vm","SandBox");
|
|---|
| 961 | } elsif ($action =~ /^updaterm$/) {
|
|---|
| 962 | pb_update2v("rm");
|
|---|
| 963 | } elsif ($action =~ /^updateve$/) {
|
|---|
| 964 | pb_update2v("ve");
|
|---|
| 965 | } elsif ($action =~ /^updatevm$/) {
|
|---|
| 966 | pb_update2v("vm");
|
|---|
| 967 | } elsif ($action =~ /^snapve$/) {
|
|---|
| 968 | pb_snap2v("ve");
|
|---|
| 969 | } elsif ($action =~ /^snapvm$/) {
|
|---|
| 970 | pb_snap2v("vm");
|
|---|
| 971 | } elsif ($action =~ /^test2pkg$/) {
|
|---|
| 972 | pb_test2pkg();
|
|---|
| 973 | } elsif ($action =~ /^test2rm$/) {
|
|---|
| 974 | pb_build2v("rm","test");
|
|---|
| 975 | } elsif ($action =~ /^test2ve$/) {
|
|---|
| 976 | pb_build2v("ve","test");
|
|---|
| 977 | } elsif ($action =~ /^test2vm$/) {
|
|---|
| 978 | pb_build2v("vm","test");
|
|---|
| 979 | } elsif ($action =~ /^newproj$/) {
|
|---|
| 980 | # Nothing to do - already done in pb_env_init
|
|---|
| 981 | } elsif ($action =~ /^getconf$/) {
|
|---|
| 982 | my $pbos = pb_distro_get_context($ENV{'PBV'});
|
|---|
| 983 | pb_log(1,"Arguments to print:".Dumper(@ARGV)."\n");
|
|---|
| 984 | pb_distro_conf_print($pbos,@ARGV);
|
|---|
| 985 | } elsif ($action =~ /^clean$/) {
|
|---|
| 986 | pb_clean();
|
|---|
| 987 | } elsif ($action =~ /^announce$/) {
|
|---|
| 988 | # For announce only. Require avoids the systematic load of these modules
|
|---|
| 989 | require DBI;
|
|---|
| 990 | require DBD::SQLite;
|
|---|
| 991 |
|
|---|
| 992 | pb_announce("Announce");
|
|---|
| 993 | } elsif ($action =~ /^cleanssh$/) {
|
|---|
| 994 | pb_announce("Clean");
|
|---|
| 995 | } elsif ($action =~ /^checkssh$/) {
|
|---|
| 996 | pb_announce("Check");
|
|---|
| 997 | } elsif ($action =~ /^checkps$/) {
|
|---|
| 998 | my ($ptr2) = pb_conf_get("vmcmd");
|
|---|
| 999 | my $vmcmd = $ptr2->{$ENV{'PBPROJ'}};
|
|---|
| 1000 | my ($vexist,$vmmport) = pb_check_ps($vmcmd,$ENV{'PBV'});
|
|---|
| 1001 | if (! $vexist) {
|
|---|
| 1002 | pb_log(0,"No VM found for $ENV{'PBV'}\n");
|
|---|
| 1003 | } else {
|
|---|
| 1004 | pb_log(0,"Found an existing VM for $ENV{'PBV'} PID: $vexist - SSH port: $vmmport\n");
|
|---|
| 1005 | }
|
|---|
| 1006 | } elsif ($action =~ /^sbx2webpkg$/) {
|
|---|
| 1007 | require DBI;
|
|---|
| 1008 | require DBD::SQLite;
|
|---|
| 1009 |
|
|---|
| 1010 | pb_cms2build("SandBox","Web");
|
|---|
| 1011 | } elsif ($action =~ /^sbx2webssh$/) {
|
|---|
| 1012 | require DBI;
|
|---|
| 1013 | require DBD::SQLite;
|
|---|
| 1014 |
|
|---|
| 1015 | pb_cms2build("SandBox","Web");
|
|---|
| 1016 | pb_send2target("Web");
|
|---|
| 1017 | } elsif ($action =~ /^cms2webpkg$/) {
|
|---|
| 1018 | require DBI;
|
|---|
| 1019 | require DBD::SQLite;
|
|---|
| 1020 |
|
|---|
| 1021 | pb_cms2build("CMS","Web");
|
|---|
| 1022 | } elsif ($action =~ /^cms2webssh$/) {
|
|---|
| 1023 | require DBI;
|
|---|
| 1024 | require DBD::SQLite;
|
|---|
| 1025 |
|
|---|
| 1026 | pb_cms2build("CMS","Web");
|
|---|
| 1027 | pb_send2target("Web");
|
|---|
| 1028 | } else {
|
|---|
| 1029 | pb_log(0,"\'$action\' is not available\n");
|
|---|
| 1030 | pb_syntax(-2,1);
|
|---|
| 1031 | }
|
|---|
| 1032 |
|
|---|
| 1033 | pb_exit();
|
|---|
| 1034 |
|
|---|
| 1035 | sub pb_cms2build {
|
|---|
| 1036 |
|
|---|
| 1037 | my $param = shift;
|
|---|
| 1038 | my $web = shift;
|
|---|
| 1039 |
|
|---|
| 1040 | my $pkg;
|
|---|
| 1041 | my @pkgs;
|
|---|
| 1042 | my $webdir;
|
|---|
| 1043 |
|
|---|
| 1044 | my %pkgs;
|
|---|
| 1045 | my $pb; # Structure to store conf info
|
|---|
| 1046 |
|
|---|
| 1047 | die "pb_cms2build requires a parameter: SandBox or CMS" if (not defined $param);
|
|---|
| 1048 |
|
|---|
| 1049 | # If Website, then pkg is only the website
|
|---|
| 1050 | if (defined $web) {
|
|---|
| 1051 | ($webdir) = pb_conf_get("webdir");
|
|---|
| 1052 | pb_log(2,"webdir: ".Dumper($webdir)."\n");
|
|---|
| 1053 | $pkgs[0] = $webdir->{$ENV{'PBPROJ'}};
|
|---|
| 1054 | $extpkgdir = $webdir;
|
|---|
| 1055 | pb_log(0,"Package: $pkgs[0]\n");
|
|---|
| 1056 | } else {
|
|---|
| 1057 | $pkg = pb_cms_get_pkg($defpkgdir,$extpkgdir);
|
|---|
| 1058 | @pkgs = @$pkg;
|
|---|
| 1059 | }
|
|---|
| 1060 |
|
|---|
| 1061 | my ($scheme, $uri) = pb_cms_init($pbinit,$param);
|
|---|
| 1062 |
|
|---|
| 1063 | # We need 2 lines here
|
|---|
| 1064 | my ($pkgv, $pkgt, $testver) = pb_conf_get_if("pkgver","pkgtag","testver");
|
|---|
| 1065 |
|
|---|
| 1066 | # declare packager and repo for filtering
|
|---|
| 1067 | my ($tmp1, $tmp2) = pb_conf_get("pbpackager","pbrepo");
|
|---|
| 1068 | $ENV{'PBPACKAGER'} = $tmp1->{$ENV{'PBPROJ'}};
|
|---|
| 1069 | $ENV{'PBREPO'} = $tmp2->{$ENV{'PBPROJ'}};
|
|---|
| 1070 | my ($delivery) = pb_conf_get_if("delivery");
|
|---|
| 1071 | $delivery->{$ENV{'PBPROJ'}} = "" if (not defined $delivery->{$ENV{'PBPROJ'}});
|
|---|
| 1072 |
|
|---|
| 1073 | # If we deal with a test dir, we want to keep the date in tar file and dir name
|
|---|
| 1074 | my $pbextdirpkg = "";
|
|---|
| 1075 | my $pbextdir = "";
|
|---|
| 1076 | if ((defined $testver) && (defined $testver->{$ENV{'PBPROJ'}}) && ($testver->{$ENV{'PBPROJ'}} =~ /true/i)) {
|
|---|
| 1077 | $pbextdirpkg = strftime("%Y%m%d%H%M%S", @date);
|
|---|
| 1078 | $pbextdir = ".0.".$pbextdirpkg;
|
|---|
| 1079 | }
|
|---|
| 1080 |
|
|---|
| 1081 | foreach my $pbpkg (@pkgs) {
|
|---|
| 1082 | $ENV{'PBPKG'} = $pbpkg;
|
|---|
| 1083 | $pbrev = $ENV{'PBREVISION'};
|
|---|
| 1084 |
|
|---|
| 1085 | if ((defined $pkgv) && (defined $pkgv->{$pbpkg})) {
|
|---|
| 1086 | $pbver = $pkgv->{$pbpkg};
|
|---|
| 1087 | } else {
|
|---|
| 1088 | $pbver = $ENV{'PBPROJVER'};
|
|---|
| 1089 | }
|
|---|
| 1090 | # If it's a test version, then build a tag to fit distributions need
|
|---|
| 1091 | if ((defined $testver) && (defined $testver->{$ENV{'PBPROJ'}}) && ($testver->{$ENV{'PBPROJ'}} =~ /true/i)) {
|
|---|
| 1092 | my $letter = "";
|
|---|
| 1093 | if ($scheme =~ /svn/) {
|
|---|
| 1094 | $letter = "s";
|
|---|
| 1095 | } elsif ($scheme =~ /cvs/) {
|
|---|
| 1096 | $letter = "c";
|
|---|
| 1097 | } elsif ($scheme =~ /svk/) {
|
|---|
| 1098 | $letter = "k";
|
|---|
| 1099 | } elsif ($scheme =~ /hg/) {
|
|---|
| 1100 | $letter = "h";
|
|---|
| 1101 | } elsif ($scheme =~ /git/) {
|
|---|
| 1102 | $letter = "g";
|
|---|
| 1103 | } else {
|
|---|
| 1104 | $letter = "f";
|
|---|
| 1105 | }
|
|---|
| 1106 | $pbtag = "0.$pbextdirpkg.$letter$pbrev";
|
|---|
| 1107 | $ENV{'PBPROJTAG'} = $pbtag;
|
|---|
| 1108 | } elsif ((defined $pkgt) && (defined $pkgt->{$pbpkg})) {
|
|---|
| 1109 | $pbtag = $pkgt->{$pbpkg};
|
|---|
| 1110 | } else {
|
|---|
| 1111 | $pbtag = $ENV{'PBPROJTAG'};
|
|---|
| 1112 | }
|
|---|
| 1113 |
|
|---|
| 1114 | pb_log(0,"\n");
|
|---|
| 1115 | pb_log(0,"Management of $pbpkg $pbver-$pbtag (rev $pbrev)\n");
|
|---|
| 1116 | die "Unable to get env var PBDESTDIR" if (not defined $ENV{'PBDESTDIR'});
|
|---|
| 1117 |
|
|---|
| 1118 | my $dest = "$ENV{'PBDESTDIR'}/$pbpkg-$pbver$pbextdir";
|
|---|
| 1119 | # Create the structure if needed
|
|---|
| 1120 | pb_mkdir_p($dest);
|
|---|
| 1121 | # Clean up dest if necessary. The export will recreate it
|
|---|
| 1122 | pb_rm_rf($dest) if (-d $dest);
|
|---|
| 1123 |
|
|---|
| 1124 | # Export CMS tree for the concerned package to dest
|
|---|
| 1125 | # And generate some additional files
|
|---|
| 1126 | $OUTPUT_AUTOFLUSH=1;
|
|---|
| 1127 |
|
|---|
| 1128 | # computes in which dir we have to work
|
|---|
| 1129 | my $dir = $defpkgdir->{$pbpkg};
|
|---|
| 1130 | $dir = $extpkgdir->{$pbpkg} if (not defined $dir);
|
|---|
| 1131 | $dir = $webdir->{$ENV{'PBPROJ'}} if (defined $web);
|
|---|
| 1132 | die "Variable \$dir not defined. Check the package name first.\nIf this is the one expected, please report to dev team with log of a verbose run and this info ".Dumper($defpkgdir,$extpkgdir,$webdir) if (not defined $dir);
|
|---|
| 1133 | pb_log(2,"def:".Dumper($defpkgdir)."ext: ".Dumper($extpkgdir)."dir: $dir\n");
|
|---|
| 1134 |
|
|---|
| 1135 | # Exporting content from CMS
|
|---|
| 1136 | my $sourcedir = undef;
|
|---|
| 1137 | my $sourceuri = $uri;
|
|---|
| 1138 | if ($param eq "SandBox") {
|
|---|
| 1139 | # Point to the local instance
|
|---|
| 1140 | $sourcedir = "$ENV{'PBDIR'}/$dir";
|
|---|
| 1141 | } else {
|
|---|
| 1142 | # Get it from a subdir of the URI with same version as localy but different root
|
|---|
| 1143 | # Only if using a real CMS
|
|---|
| 1144 | my ($scheme, $account, $host, $port, $path) = pb_get_uri($uri);
|
|---|
| 1145 | if (($scheme !~ /^file/) && ($scheme !~ /^(ht|f)tp/)) {
|
|---|
| 1146 | $sourceuri = "$ENV{'PBDIR'}/$dir";
|
|---|
| 1147 | $sourceuri =~ s|^$ENV{'PBPROJDIR'}/|$uri/|;
|
|---|
| 1148 | }
|
|---|
| 1149 | }
|
|---|
| 1150 | my $preserve = pb_vcs_export($sourceuri,$sourcedir,$dest);
|
|---|
| 1151 |
|
|---|
| 1152 | # Generated fake content for test versions to speed up stuff
|
|---|
| 1153 | my $chglog;
|
|---|
| 1154 |
|
|---|
| 1155 | # Get project info on authors and log file
|
|---|
| 1156 | # TODO: Make it CMS aware
|
|---|
| 1157 | $chglog = "$ENV{'PBROOTDIR'}/$pbpkg/pbcl";
|
|---|
| 1158 | $chglog = "$ENV{'PBROOTDIR'}/pbcl" if (! -f $chglog);
|
|---|
| 1159 | $chglog = undef if (! -f $chglog);
|
|---|
| 1160 |
|
|---|
| 1161 | # TODO: Make it CMS aware
|
|---|
| 1162 | my $authors = "$ENV{'PBROOTDIR'}/$pbpkg/pbauthors";
|
|---|
| 1163 | $authors = "$ENV{'PBROOTDIR'}/pbauthors" if (! -f $authors);
|
|---|
| 1164 | $authors = "/dev/null" if (! -f $authors);
|
|---|
| 1165 |
|
|---|
| 1166 | # Extract cms log history and store it
|
|---|
| 1167 | if ((defined $chglog) && (! -f "$dest/NEWS")) {
|
|---|
| 1168 | pb_log(2,"Generating NEWS file from $chglog\n");
|
|---|
| 1169 | copy($chglog,"$dest/NEWS") || die "Unable to create $dest/NEWS";
|
|---|
| 1170 | }
|
|---|
| 1171 | pb_cms_log($scheme,"$ENV{'PBDIR'}/$dir",$dest,$chglog,$authors,$testver);
|
|---|
| 1172 |
|
|---|
| 1173 | my %build;
|
|---|
| 1174 | # We want to at least build for the underlying distro
|
|---|
| 1175 | # except if a target was given, in which case we only build for it
|
|---|
| 1176 | # if -t was passed without target then build for the native distro.
|
|---|
| 1177 | my $pbos = pb_distro_get_context($pbtarget);
|
|---|
| 1178 | my $tmpl = pb_get_distros($pbos,$pbtarget);
|
|---|
| 1179 |
|
|---|
| 1180 | # Setup $pb structure to allow filtering later on, on files using that structure
|
|---|
| 1181 | $pb->{'tag'} = $pbtag;
|
|---|
| 1182 | $pb->{'rev'} = $pbrev;
|
|---|
| 1183 | $pb->{'ver'} = $pbver;
|
|---|
| 1184 | $pb->{'pkg'} = $pbpkg;
|
|---|
| 1185 | $pb->{'suf'} = $pbos->{'suffix'};
|
|---|
| 1186 | $pb->{'realpkg'} = $pbpkg;
|
|---|
| 1187 | $pb->{'date'} = $pbdate;
|
|---|
| 1188 | $pb->{'defpkgdir'} = $defpkgdir;
|
|---|
| 1189 | $pb->{'extpkgdir'} = $extpkgdir;
|
|---|
| 1190 | $pb->{'chglog'} = $chglog;
|
|---|
| 1191 | $pb->{'extdir'} = $pbextdir;
|
|---|
| 1192 | $pb->{'packager'} = $ENV{'PBPACKAGER'};
|
|---|
| 1193 | $pb->{'proj'} = $ENV{'PBPROJ'};
|
|---|
| 1194 | $pb->{'repo'} = "$ENV{'PBREPO'}/$delivery->{$ENV{'PBPROJ'}}";
|
|---|
| 1195 | $pb->{'patches'} = ();
|
|---|
| 1196 | $pb->{'sources'} = ();
|
|---|
| 1197 |
|
|---|
| 1198 | my $tmpd = "$ENV{'PBTMP'}/cms.$$";
|
|---|
| 1199 | pb_mkdir_p($tmpd) if (defined $pbparallel);
|
|---|
| 1200 |
|
|---|
| 1201 | # Get only all.pbf filter at this stage for pbinit
|
|---|
| 1202 | my $ptr = pb_get_filters($pbpkg);
|
|---|
| 1203 |
|
|---|
| 1204 | # Do not do that for website
|
|---|
| 1205 | if (not defined $web) {
|
|---|
| 1206 | my %virt;
|
|---|
| 1207 | # De-duplicate similar VM/VE/RM
|
|---|
| 1208 | foreach my $d (split(/,/,$tmpl)) {
|
|---|
| 1209 | # skip ill-formatted vms (name-ver-arch)
|
|---|
| 1210 | next if ($d !~ /-/);
|
|---|
| 1211 | $virt{$d} = $d;
|
|---|
| 1212 | }
|
|---|
| 1213 |
|
|---|
| 1214 | # Try to use // processing here
|
|---|
| 1215 | my $all_ok = 1;
|
|---|
| 1216 | my $pm = new Parallel::ForkManager($pbparallel) if (defined $pbparallel);
|
|---|
| 1217 | $pm->run_on_finish(sub { my ($pid, $code, $id, $signal, $dump) = @_;
|
|---|
| 1218 | $all_ok = 0 unless (($code == 0) && ($signal == 0) && ($dump == 0)); }) if (defined $pbparallel);
|
|---|
| 1219 |
|
|---|
| 1220 | pb_log(0,"Preparing delivery ...\n");
|
|---|
| 1221 | foreach my $v (keys %virt) {
|
|---|
| 1222 | $pm->start and next if (defined $pbparallel);
|
|---|
| 1223 |
|
|---|
| 1224 | # Distro context
|
|---|
| 1225 | my $pbos = pb_distro_get_context($v);
|
|---|
| 1226 |
|
|---|
| 1227 | $pb->{'pbos'} = $pbos;
|
|---|
| 1228 | $pb->{'suf'} = $pbos->{'suffix'};
|
|---|
| 1229 | pb_log(3,"DEBUG: pb: ".Dumper($pb)."\n");
|
|---|
| 1230 |
|
|---|
| 1231 | # Get all filters to apply
|
|---|
| 1232 | $ptr = pb_get_filters($pbpkg,$pbos);
|
|---|
| 1233 |
|
|---|
| 1234 | pb_log(2,"DEBUG Filtering PBDATE => $pbdate, PBTAG => $pbtag, PBVER => $pbver\n");
|
|---|
| 1235 |
|
|---|
| 1236 | # We need to compute the real name of the package
|
|---|
| 1237 | my $pbrealpkg = pb_cms_get_real_pkg($pbpkg,$pbos->{'type'});
|
|---|
| 1238 | $pb->{'realpkg'} = $pbrealpkg;
|
|---|
| 1239 | pb_log(1,"Virtual package $pbpkg has a real package name of $pbrealpkg on $pbos->{'name'}-$pbos->{'version'}\n") if ($pbrealpkg ne $pbpkg);
|
|---|
| 1240 |
|
|---|
| 1241 | # Filter build files from the less precise up to the most with overloading
|
|---|
| 1242 | # Filter all files found, keeping the name, and generating in dest
|
|---|
| 1243 |
|
|---|
| 1244 | # Find all build files first relatively to PBROOTDIR
|
|---|
| 1245 | # Find also all specific files referenced in the .pb conf file
|
|---|
| 1246 | my %bfiles = ();
|
|---|
| 1247 | my %pkgfiles = ();
|
|---|
| 1248 | # Used in Filter.pm by pb_filter_file
|
|---|
| 1249 |
|
|---|
| 1250 | $build{$v} = "no";
|
|---|
| 1251 | if (-d "$ENV{'PBROOTDIR'}/$pbpkg/$pbos->{'os'}") {
|
|---|
| 1252 | pb_list_bfiles("$ENV{'PBROOTDIR'}/$pbpkg/$pbos->{'os'}",$pbpkg,\%bfiles,\%pkgfiles,$supfiles);
|
|---|
| 1253 | $build{$v} = "yes";
|
|---|
| 1254 | }
|
|---|
| 1255 | if (-d "$ENV{'PBROOTDIR'}/$pbpkg/$pbos->{'type'}") {
|
|---|
| 1256 | pb_list_bfiles("$ENV{'PBROOTDIR'}/$pbpkg/$pbos->{'type'}",$pbpkg,\%bfiles,\%pkgfiles,$supfiles);
|
|---|
| 1257 | $build{$v} = "yes";
|
|---|
| 1258 | }
|
|---|
| 1259 | if (-d "$ENV{'PBROOTDIR'}/$pbpkg/$pbos->{'family'}") {
|
|---|
| 1260 | pb_list_bfiles("$ENV{'PBROOTDIR'}/$pbpkg/$pbos->{'family'}",$pbpkg,\%bfiles,\%pkgfiles,$supfiles);
|
|---|
| 1261 | $build{$v} = "yes";
|
|---|
| 1262 | }
|
|---|
| 1263 | if (-d "$ENV{'PBROOTDIR'}/$pbpkg/$pbos->{'name'}") {
|
|---|
| 1264 | pb_list_bfiles("$ENV{'PBROOTDIR'}/$pbpkg/$pbos->{'name'}",$pbpkg,\%bfiles,\%pkgfiles,$supfiles);
|
|---|
| 1265 | $build{$v} = "yes";
|
|---|
| 1266 | }
|
|---|
| 1267 | if (-d "$ENV{'PBROOTDIR'}/$pbpkg/$pbos->{'name'}-$pbos->{'version'}") {
|
|---|
| 1268 | pb_list_bfiles("$ENV{'PBROOTDIR'}/$pbpkg/$pbos->{'name'}-$pbos->{'version'}",$pbpkg,\%bfiles,\%pkgfiles,$supfiles);
|
|---|
| 1269 | $build{$v} = "yes";
|
|---|
| 1270 | }
|
|---|
| 1271 | if (-d "$ENV{'PBROOTDIR'}/$pbpkg/$pbos->{'name'}-$pbos->{'version'}-$pbos->{'arch'}") {
|
|---|
| 1272 | pb_list_bfiles("$ENV{'PBROOTDIR'}/$pbpkg/$pbos->{'name'}-$pbos->{'version'}-$pbos->{'arch'}",$pbpkg,\%bfiles,\%pkgfiles,$supfiles);
|
|---|
| 1273 | $build{$v} = "yes";
|
|---|
| 1274 | }
|
|---|
| 1275 | pb_log(2,"DEBUG($v) bfiles: ".Dumper(\%bfiles)."\n");
|
|---|
| 1276 |
|
|---|
| 1277 | if ($build{$v} ne "no") {
|
|---|
| 1278 | # Apply now all the filters on all the files concerned
|
|---|
| 1279 | # destination dir depends on the type of file
|
|---|
| 1280 | # For patch support
|
|---|
| 1281 | # TODO: Make it CMS aware
|
|---|
| 1282 | $pb->{'patches'} = pb_list_sfiles("$ENV{'PBROOTDIR'}/$pbpkg/pbpatch", $pb->{'patches'}, $pbos, "$ENV{'PBROOTDIR'}/$pbpkg/pbextpatch");
|
|---|
| 1283 | pb_log(2,"DEBUG($v) patches: ".Dumper($pb->{'patches'})."\n");
|
|---|
| 1284 | # TODO: Make it CMS aware
|
|---|
| 1285 | $pb->{'sources'} = pb_list_sfiles("$ENV{'PBROOTDIR'}/$pbpkg/pbsrc", $pb->{'sources'}, $pbos, "$ENV{'PBROOTDIR'}/$pbpkg/pbextsrc");
|
|---|
| 1286 | pb_log(2,"DEBUG($v) sources: ".Dumper($pb->{'sources'})."\n");
|
|---|
| 1287 |
|
|---|
| 1288 | if (defined $pb->{'patches'}->{$v}) {
|
|---|
| 1289 | # Filter potential patches (local + remote)
|
|---|
| 1290 | pb_mkdir_p("$dest/pbconf/$v/pbpatch");
|
|---|
| 1291 | # If Debian based distribution, then prepare what will be done at build time
|
|---|
| 1292 | my ($patchcmd,$patchopt);
|
|---|
| 1293 | if ($pbos->{'type'} eq "deb") {
|
|---|
| 1294 | ($patchcmd,$patchopt) = pb_distro_get_param($pbos,pb_conf_get_if("ospatchcmd","ospatchopt"));
|
|---|
| 1295 | open(SCRIPT,"> $dest/pbconf/$v/pbpatch/pbapplypatch") || die "Unable to create $dest/pbconf/$v/pbpatch/pbapplypatch";
|
|---|
| 1296 | print SCRIPT "#!/bin/bash\n";
|
|---|
| 1297 | print SCRIPT "set -x\n" if ($pbdebug gt 1);
|
|---|
| 1298 | }
|
|---|
| 1299 | foreach my $pf (split(/,/,$pb->{'patches'}->{$v})) {
|
|---|
| 1300 | my $pp = basename($pf);
|
|---|
| 1301 | pb_vcs_export($pf,undef,"$dest/pbconf/$v/pbpatch");
|
|---|
| 1302 | pb_filter_file_inplace($ptr,"$dest/pbconf/$v/pbpatch/$pp",$pb);
|
|---|
| 1303 | pb_system("gzip -9f $dest/pbconf/$v/pbpatch/$pp","","quiet");
|
|---|
| 1304 | if ($pbos->{'type'} eq "deb") {
|
|---|
| 1305 | # If Debian based distribution, then prepare what will be done at build time
|
|---|
| 1306 | # by applying the patches that will be available under the debian/patches dir
|
|---|
| 1307 | print SCRIPT "$patchcmd $patchopt \< debian/patches/$pp\n";
|
|---|
| 1308 | }
|
|---|
| 1309 | }
|
|---|
| 1310 | if ($pbos->{'type'} eq "deb") {
|
|---|
| 1311 | close(SCRIPT);
|
|---|
| 1312 | chmod 0755,"$dest/pbconf/$v/pbpatch/pbapplypatch";
|
|---|
| 1313 | }
|
|---|
| 1314 | #pb_system("cat $dest/pbconf/$v/pbpatch/pbapplypatch","APPLY","verbose");
|
|---|
| 1315 | }
|
|---|
| 1316 | if (defined $pb->{'sources'}->{$v}) {
|
|---|
| 1317 | pb_mkdir_p("$dest/pbconf/$v/pbsrc");
|
|---|
| 1318 | foreach my $pf (split(/,/,$pb->{'sources'}->{$v})) {
|
|---|
| 1319 | my $pp = basename($pf);
|
|---|
| 1320 | pb_vcs_export($pf,undef,"$dest/pbconf/$v/pbsrc");
|
|---|
| 1321 | pb_filter_file_inplace($ptr,"$dest/pbconf/$v/pbsrc/$pp",$pb);
|
|---|
| 1322 | }
|
|---|
| 1323 | }
|
|---|
| 1324 | # Filter build files at the end, as they depend on patches and sources
|
|---|
| 1325 | foreach my $f (keys %bfiles) {
|
|---|
| 1326 | pb_filter_file("$ENV{'PBROOTDIR'}/$bfiles{$f}",$ptr,"$dest/pbconf/$v/$f",$pb);
|
|---|
| 1327 | }
|
|---|
| 1328 | foreach my $f (keys %pkgfiles) {
|
|---|
| 1329 | pb_filter_file("$ENV{'PBROOTDIR'}/$pkgfiles{$f}",$ptr,"$dest/pbconf/$v/$f",$pb);
|
|---|
| 1330 | }
|
|---|
| 1331 | }
|
|---|
| 1332 |
|
|---|
| 1333 | if (defined $pbparallel) {
|
|---|
| 1334 | # Communicate results back to parent
|
|---|
| 1335 | my $str = "";
|
|---|
| 1336 | $str .= "build $v = $build{$v}\n" if (defined $build{$v});
|
|---|
| 1337 | $str .= "patches $v = $pb->{'patches'}->{$v}\n" if (defined $pb->{'patches'}->{$v});
|
|---|
| 1338 | $str .= "sources $v = $pb->{'sources'}->{$v}\n" if (defined $pb->{'sources'}->{$v});
|
|---|
| 1339 | pb_set_content("$tmpd/$$","$str");
|
|---|
| 1340 | $pm->finish;
|
|---|
| 1341 | }
|
|---|
| 1342 | }
|
|---|
| 1343 | # In the parent, we need to get the result from the children
|
|---|
| 1344 | $pm->wait_all_children if (defined $pbparallel);
|
|---|
| 1345 | die "Aborting, one or more of the children failed." if ((not $all_ok) && ($Global::pb_stop_on_error));
|
|---|
| 1346 | my $made = "";
|
|---|
| 1347 | my %h = ();
|
|---|
| 1348 | my %tmp;
|
|---|
| 1349 | my %tmp2;
|
|---|
| 1350 | my $pt;
|
|---|
| 1351 | my $k;
|
|---|
| 1352 |
|
|---|
| 1353 | foreach $k (<$tmpd/*>) {
|
|---|
| 1354 | $made .= pb_get_content($k);
|
|---|
| 1355 | }
|
|---|
| 1356 | pb_rm_rf($tmpd);
|
|---|
| 1357 | pb_log(3,"MADE:\n$made");
|
|---|
| 1358 |
|
|---|
| 1359 | # Rebuild local hashes
|
|---|
| 1360 | foreach $k (split(/\n/,$made)) {
|
|---|
| 1361 | if ($k =~ /^\s*([A-z0-9-_]+)\s+([[A-z0-9-_.]+)\s*=\s*(.+)$/) {
|
|---|
| 1362 | $h{$1}->{$2}=$3;
|
|---|
| 1363 | }
|
|---|
| 1364 | }
|
|---|
| 1365 | pb_log(2,"HASH: ".Dumper(%h));
|
|---|
| 1366 |
|
|---|
| 1367 | # Patches
|
|---|
| 1368 | pb_log(0,"Delivered and compressed patches ");
|
|---|
| 1369 | $pt = $h{'patches'};
|
|---|
| 1370 | foreach $k (keys %$pt) {
|
|---|
| 1371 | foreach my $v1 (split(/,/,$pt->{$k})) {
|
|---|
| 1372 | $tmp{$v1} = "";
|
|---|
| 1373 | }
|
|---|
| 1374 | }
|
|---|
| 1375 | if (keys %tmp) {
|
|---|
| 1376 | foreach $k (keys %tmp) {
|
|---|
| 1377 | pb_log(0,"$k ");
|
|---|
| 1378 | }
|
|---|
| 1379 | } else {
|
|---|
| 1380 | pb_log(0,"N/A");
|
|---|
| 1381 | }
|
|---|
| 1382 | pb_log(0,"\n");
|
|---|
| 1383 |
|
|---|
| 1384 | # Sources
|
|---|
| 1385 | pb_log(0,"Delivered additional sources ");
|
|---|
| 1386 | $pt = $h{'sources'};
|
|---|
| 1387 | foreach $k (keys %$pt) {
|
|---|
| 1388 | foreach my $v1 (split(/,/,$pt->{$k})) {
|
|---|
| 1389 | $tmp2{$v1} = "";
|
|---|
| 1390 | }
|
|---|
| 1391 | }
|
|---|
| 1392 | if (keys %tmp2) {
|
|---|
| 1393 | foreach $k (keys %tmp2) {
|
|---|
| 1394 | pb_log(0,"$k ");
|
|---|
| 1395 | }
|
|---|
| 1396 | } else {
|
|---|
| 1397 | pb_log(0,"N/A");
|
|---|
| 1398 | }
|
|---|
| 1399 | pb_log(0,"\n");
|
|---|
| 1400 |
|
|---|
| 1401 | # Build files
|
|---|
| 1402 | my @found;
|
|---|
| 1403 | my @notfound;
|
|---|
| 1404 | $pt = $h{'build'};
|
|---|
| 1405 | foreach my $b (keys %$pt) {
|
|---|
| 1406 | push @found,$b if ($pt->{$b} =~ /yes/);
|
|---|
| 1407 | push @notfound,$b if ($pt->{$b} =~ /no/);
|
|---|
| 1408 | }
|
|---|
| 1409 | pb_log(0,"Build files have been generated for ... ".join(',',sort(@found))."\n") if (@found);
|
|---|
| 1410 | pb_log(0,"No Build files found for ".join(',',sort(@notfound))."\n") if (@notfound);
|
|---|
| 1411 |
|
|---|
| 1412 | } else {
|
|---|
| 1413 | # Instead call News generation
|
|---|
| 1414 | pb_web_news2html($dest);
|
|---|
| 1415 | # And create an empty pbconf
|
|---|
| 1416 | pb_mkdir_p("$dest/pbconf");
|
|---|
| 1417 | # And prepare the pbscript to execute remotely
|
|---|
| 1418 | open(SCRIPT,"> $ENV{'PBTMP'}/pbscript") || die "Unable to create $ENV{'PBTMP'}/pbscript";
|
|---|
| 1419 | print SCRIPT "#!/bin/bash\n";
|
|---|
| 1420 | print SCRIPT "#set -x\n";
|
|---|
| 1421 | print SCRIPT "echo ... Extracting Website content\n";
|
|---|
| 1422 | print SCRIPT "find . -type f | grep -Ev '^./$pbpkg-$pbver$pbextdir.tar.gz|^./pbscript' | xargs rm -f non-existent\n";
|
|---|
| 1423 | print SCRIPT "find * -type d -depth | xargs rmdir 2> /dev/null \n";
|
|---|
| 1424 | print SCRIPT "tar xfz $pbpkg-$pbver$pbextdir.tar.gz\n";
|
|---|
| 1425 | print SCRIPT "mv $pbpkg-$pbver$pbextdir/* .\n";
|
|---|
| 1426 | print SCRIPT "rm -f $pbpkg-$pbver$pbextdir.tar.gz\n";
|
|---|
| 1427 | print SCRIPT "rmdir $pbpkg-$pbver$pbextdir\n";
|
|---|
| 1428 | print SCRIPT "find . -type f -print0 | xargs -0 chmod 644\n";
|
|---|
| 1429 | print SCRIPT "find . -type d -print0 | xargs -0 chmod 755\n";
|
|---|
| 1430 | close(SCRIPT);
|
|---|
| 1431 | chmod 0755,"$ENV{'PBTMP'}/pbscript";
|
|---|
| 1432 | }
|
|---|
| 1433 |
|
|---|
| 1434 | # Apply filters to the non-build files
|
|---|
| 1435 | my $liste ="";
|
|---|
| 1436 | if (defined $filteredfiles->{$pbpkg}) {
|
|---|
| 1437 | foreach my $f (split(/,/,$filteredfiles->{$pbpkg})) {
|
|---|
| 1438 | pb_filter_file_inplace($ptr,"$dest/$f",$pb);
|
|---|
| 1439 | $liste = "$f $liste";
|
|---|
| 1440 | }
|
|---|
| 1441 | }
|
|---|
| 1442 | pb_log(2,"Files ".$liste."have been filtered\n");
|
|---|
| 1443 |
|
|---|
| 1444 | # TODO: Make it CMS aware
|
|---|
| 1445 | # Execute the pbinit script if any
|
|---|
| 1446 | if (-x "$ENV{'PBROOTDIR'}/$pbpkg/pbinit") {
|
|---|
| 1447 | pb_filter_file("$ENV{'PBROOTDIR'}/$pbpkg/pbinit",$ptr,"$ENV{'PBTMP'}/pbinit",$pb);
|
|---|
| 1448 | chmod 0755,"$ENV{'PBTMP'}/pbinit";
|
|---|
| 1449 | pb_system("cd $dest ; $ENV{'PBTMP'}/pbinit","Executing init script from $ENV{'PBROOTDIR'}/$pbpkg/pbinit under $dest","verbose");
|
|---|
| 1450 | }
|
|---|
| 1451 |
|
|---|
| 1452 | # Do we have additional script to run to prepare the environement for the project ?
|
|---|
| 1453 | # Then include it in the pbconf delivery
|
|---|
| 1454 | foreach my $pbvf (<$ENV{'PBROOTDIR'}/pbv*.pre>,<$ENV{'PBROOTDIR'}/pbv*.post>, <$ENV{'PBROOTDIR'}/pbtest*>) {
|
|---|
| 1455 | if (-x "$pbvf") {
|
|---|
| 1456 | my $target = "$ENV{'PBDESTDIR'}/".basename($pbvf);
|
|---|
| 1457 | pb_filter_file("$pbvf",$ptr,$target,$pb);
|
|---|
| 1458 | chmod 0755,"$target";
|
|---|
| 1459 | }
|
|---|
| 1460 | }
|
|---|
| 1461 |
|
|---|
| 1462 | # Prepare the dest directory for archive
|
|---|
| 1463 | chdir "$ENV{'PBDESTDIR'}" || die "Unable to change dir to $ENV{'PBDESTDIR'}";
|
|---|
| 1464 | if (defined $preserve) {
|
|---|
| 1465 | # In that case we want to preserve the original tar file for checksum purposes
|
|---|
| 1466 | # The one created is btw equivalent in that case to this one
|
|---|
| 1467 | # Maybe check basename of both to be sure they are the same ?
|
|---|
| 1468 | pb_log(0,"Preserving original tar file ");
|
|---|
| 1469 | move("$preserve","$pbpkg-$pbver$pbextdir.tar.gz");
|
|---|
| 1470 | } else {
|
|---|
| 1471 | # Possibility to look at PBSRC to guess more the filename
|
|---|
| 1472 | pb_system("tar cfz $pbpkg-$pbver$pbextdir.tar.gz --exclude=$pbpkg-$pbver$pbextdir/pbconf $pbpkg-$pbver$pbextdir","Creating $pbpkg tar files compressed");
|
|---|
| 1473 | }
|
|---|
| 1474 | pb_log(0,"Under $ENV{'PBDESTDIR'}/$pbpkg-$pbver$pbextdir.tar.gz\n");
|
|---|
| 1475 | pb_system("tar cfz $pbpkg-$pbver$pbextdir.pbconf.tar.gz $pbpkg-$pbver$pbextdir/pbconf","Creating pbconf tar files compressed");
|
|---|
| 1476 | pb_log(0,"Under $ENV{'PBDESTDIR'}/$pbpkg-$pbver$pbextdir.pbconf.tar.gz\n");
|
|---|
| 1477 |
|
|---|
| 1478 | # Keep track of version-tag per pkg
|
|---|
| 1479 | $pkgs{$pbpkg} = "$pbver-$pbtag";
|
|---|
| 1480 |
|
|---|
| 1481 | # Final cleanup
|
|---|
| 1482 | pb_rm_rf($dest) if (-d $dest);
|
|---|
| 1483 | }
|
|---|
| 1484 |
|
|---|
| 1485 | # Keep track of per package version
|
|---|
| 1486 | pb_log(2,"DEBUG pkgs: ".Dumper(%pkgs)."\n");
|
|---|
| 1487 | open(PKG,"> $ENV{'PBDESTDIR'}/$ENV{'PBPROJVER'}-$ENV{'PBPROJTAG'}.pb") || die "Unable to create $ENV{'PBDESTDIR'}/$ENV{'PBPROJVER'}-$ENV{'PBPROJTAG'}.pb";
|
|---|
| 1488 | foreach my $pbpkg (keys %pkgs) {
|
|---|
| 1489 | print PKG "pbpkg $pbpkg = $pkgs{$pbpkg}\n";
|
|---|
| 1490 | }
|
|---|
| 1491 | close(PKG);
|
|---|
| 1492 |
|
|---|
| 1493 | # Keep track of what is generated by default
|
|---|
| 1494 | # We need to store the dir and info on version-tag
|
|---|
| 1495 | # Base our content on the existing .pb file
|
|---|
| 1496 | copy("$ENV{'PBROOTDIR'}/$ENV{'PBPROJ'}.pb","$ENV{'PBDESTDIR'}/pbrc");
|
|---|
| 1497 | open(LAST,">> $ENV{'PBDESTDIR'}/pbrc") || die "Unable to create $ENV{'PBDESTDIR'}/pbrc";
|
|---|
| 1498 | print LAST "pbroot $ENV{'PBPROJ'} = $ENV{'PBROOTDIR'}\n";
|
|---|
| 1499 | print LAST "projver $ENV{'PBPROJ'} = $ENV{'PBPROJVER'}\n";
|
|---|
| 1500 | print LAST "projtag $ENV{'PBPROJ'} = $ENV{'PBPROJTAG'}\n";
|
|---|
| 1501 | print LAST "pbpackager $ENV{'PBPROJ'} = $ENV{'PBPACKAGER'}\n";
|
|---|
| 1502 | print LAST "pbextdir $ENV{'PBPROJ'} = $pbextdir\n";
|
|---|
| 1503 | close(LAST);
|
|---|
| 1504 | }
|
|---|
| 1505 |
|
|---|
| 1506 | sub pb_test2pkg {
|
|---|
| 1507 | # Get the running distro to test on
|
|---|
| 1508 | my $pbos = pb_distro_get_context();
|
|---|
| 1509 |
|
|---|
| 1510 | # Get list of packages to test
|
|---|
| 1511 | # Get content saved in cms2build
|
|---|
| 1512 | my $ptr = pb_get_pkg();
|
|---|
| 1513 | @pkgs = @$ptr;
|
|---|
| 1514 |
|
|---|
| 1515 | # Additional potential repo
|
|---|
| 1516 | pb_distro_setuprepo($pbos);
|
|---|
| 1517 | foreach my $pbpkg (@pkgs) {
|
|---|
| 1518 | # We need to install the package to test, and deps brought with it
|
|---|
| 1519 | pb_distro_installdeps(undef,$pbos,$pbpkg);
|
|---|
| 1520 | pb_system("$ENV{'PBDESTDIR'}/pbtest","Launching test for $pbpkg","verbose");
|
|---|
| 1521 | }
|
|---|
| 1522 | }
|
|---|
| 1523 |
|
|---|
| 1524 | sub pb_build2prep {
|
|---|
| 1525 |
|
|---|
| 1526 | pb_log(0,"INFO: ------ Starting to prepare build environement ------\n");
|
|---|
| 1527 |
|
|---|
| 1528 | # Get the running distro to build on
|
|---|
| 1529 | my $pbos = pb_distro_get_context();
|
|---|
| 1530 |
|
|---|
| 1531 | # If needed we may add repository to the build env
|
|---|
| 1532 | pb_distro_setuprepo($pbos);
|
|---|
| 1533 |
|
|---|
| 1534 | # Get list of packages to build
|
|---|
| 1535 | my $ptr = pb_get_pkg();
|
|---|
| 1536 | @pkgs = @$ptr;
|
|---|
| 1537 |
|
|---|
| 1538 | # Get content saved in cms2build
|
|---|
| 1539 | my ($pkg) = pb_conf_read("$ENV{'PBDESTDIR'}/$ENV{'PBPROJVER'}-$ENV{'PBPROJTAG'}.pb","pbpkg");
|
|---|
| 1540 | $pkg = { } if (not defined $pkg);
|
|---|
| 1541 | my $pbextdir = pb_get_extdir();
|
|---|
| 1542 |
|
|---|
| 1543 | foreach my $pbpkg (@pkgs) {
|
|---|
| 1544 | my $vertag = $pkg->{$pbpkg};
|
|---|
| 1545 | my @buildfiles;
|
|---|
| 1546 | pb_log(2,"Vertag: $vertag\n");
|
|---|
| 1547 | # get the version of the current package - maybe different
|
|---|
| 1548 | ($pbver,$pbtag) = split(/-/,$vertag);
|
|---|
| 1549 |
|
|---|
| 1550 | my $src2="$ENV{'PBDESTDIR'}/$pbpkg-$pbver$pbextdir.pbconf.tar.gz";
|
|---|
| 1551 | pb_log(2,"Pbconf file: $src2\n");
|
|---|
| 1552 | pb_log(2,"Working directory: $ENV{'PBBUILDDIR'}\n");
|
|---|
| 1553 |
|
|---|
| 1554 | my $ftype;
|
|---|
| 1555 | if ($pbos->{'type'} eq "rpm") {
|
|---|
| 1556 | $ftype = "\.spec\$";
|
|---|
| 1557 | } elsif ($pbos->{'type'} eq "deb") {
|
|---|
| 1558 | $ftype = "\/control\$";
|
|---|
| 1559 | } elsif ($pbos->{'type'} eq "ebuild") {
|
|---|
| 1560 | $ftype = "\.ebuild\$";
|
|---|
| 1561 | } elsif ($pbos->{'type'} eq "tgz") {
|
|---|
| 1562 | $ftype = "\/pbslack\$";
|
|---|
| 1563 | } elsif ($pbos->{'type'} eq "pkg") {
|
|---|
| 1564 | # Solaris - no deps management up to Solaris 10
|
|---|
| 1565 | } elsif ($pbos->{'type'} eq "hpux") {
|
|---|
| 1566 | # TODO: HP-UX
|
|---|
| 1567 | } else {
|
|---|
| 1568 | die "Unknown OS type format $pbos->{'type'}";
|
|---|
| 1569 | }
|
|---|
| 1570 |
|
|---|
| 1571 | @buildfiles = pb_extract_build_files($src2,"$pbpkg-$pbver$pbextdir/pbconf/$pbos->{'name'}-$pbos->{'version'}-$pbos->{'arch'}/","$ENV{'PBTMP'}","spec");
|
|---|
| 1572 | pb_log(2,"buildfiles ".Dumper(\@buildfiles)."\n");
|
|---|
| 1573 | foreach my $f (@buildfiles) {
|
|---|
| 1574 | if ($f =~ /$ftype/) {
|
|---|
| 1575 | pb_distro_installdeps($f,$pbos);
|
|---|
| 1576 | last;
|
|---|
| 1577 | }
|
|---|
| 1578 | }
|
|---|
| 1579 | }
|
|---|
| 1580 | pb_log(0,"INFO: ------ Finished preparing build environment ------\n");
|
|---|
| 1581 | }
|
|---|
| 1582 |
|
|---|
| 1583 | sub pb_build2pkg {
|
|---|
| 1584 |
|
|---|
| 1585 | my $do_install = shift;
|
|---|
| 1586 |
|
|---|
| 1587 | pb_log(0,"INFO: ------ Starting to build package ------\n");
|
|---|
| 1588 | # Get the running distro to build on
|
|---|
| 1589 | my $pbos = pb_distro_get_context();
|
|---|
| 1590 |
|
|---|
| 1591 | # Get list of packages to build
|
|---|
| 1592 | my $ptr = pb_get_pkg();
|
|---|
| 1593 | @pkgs = @$ptr;
|
|---|
| 1594 |
|
|---|
| 1595 | # Get content saved in cms2build
|
|---|
| 1596 | my ($pkg) = pb_conf_read("$ENV{'PBDESTDIR'}/$ENV{'PBPROJVER'}-$ENV{'PBPROJTAG'}.pb","pbpkg");
|
|---|
| 1597 | $pkg = { } if (not defined $pkg);
|
|---|
| 1598 | my $pbextdir = pb_get_extdir();
|
|---|
| 1599 |
|
|---|
| 1600 | pb_mkdir_p("$ENV{'PBBUILDDIR'}") if (! -d "$ENV{'PBBUILDDIR'}");
|
|---|
| 1601 | chdir "$ENV{'PBBUILDDIR'}" || die "Unable to chdir to $ENV{'PBBUILDDIR'}";
|
|---|
| 1602 | my $made = ""; # pkgs made during build
|
|---|
| 1603 | my $pm;
|
|---|
| 1604 | my $all_ok = 1;
|
|---|
| 1605 |
|
|---|
| 1606 | if (defined $pbparallel) {
|
|---|
| 1607 | $pm = new Parallel::ForkManager($pbparallel);
|
|---|
| 1608 | $pm->run_on_finish(sub { my ($pid, $code, $id, $signal, $dump) = @_;
|
|---|
| 1609 | $all_ok = 0 unless (($code == 0) && ($signal == 0) && ($dump == 0)); });
|
|---|
| 1610 | }
|
|---|
| 1611 |
|
|---|
| 1612 | # We need to communicate info back from the children if parallel so prepare a dir for that
|
|---|
| 1613 | my $tmpd = "$ENV{'PBTMP'}/build.$$";
|
|---|
| 1614 | pb_mkdir_p($tmpd) if (defined $pbparallel);
|
|---|
| 1615 |
|
|---|
| 1616 | # Do it here as this doesn't work in // mode as it dies if it fails
|
|---|
| 1617 | if ($pbos->{'type'} eq "rpm") {
|
|---|
| 1618 | foreach my $d ('RPMS','SRPMS','SPECS','SOURCES','BUILD') {
|
|---|
| 1619 | if (! -d "$ENV{'PBBUILDDIR'}/$d") {
|
|---|
| 1620 | pb_mkdir_p("$ENV{'PBBUILDDIR'}/$d");
|
|---|
| 1621 | }
|
|---|
| 1622 | }
|
|---|
| 1623 | }
|
|---|
| 1624 |
|
|---|
| 1625 | foreach my $pbpkg (@pkgs) {
|
|---|
| 1626 | $pm->start and next if (defined $pbparallel);
|
|---|
| 1627 |
|
|---|
| 1628 | my $vertag = $pkg->{$pbpkg};
|
|---|
| 1629 | pb_log(2,"Vertag: $vertag\n");
|
|---|
| 1630 | # get the version of the current package - maybe different
|
|---|
| 1631 | ($pbver,$pbtag) = split(/-/,$vertag);
|
|---|
| 1632 |
|
|---|
| 1633 | my $src="$ENV{'PBDESTDIR'}/$pbpkg-$pbver$pbextdir.tar.gz";
|
|---|
| 1634 | my $src2="$ENV{'PBDESTDIR'}/$pbpkg-$pbver$pbextdir.pbconf.tar.gz";
|
|---|
| 1635 | pb_log(2,"Source file: $src\n");
|
|---|
| 1636 | pb_log(2,"Pbconf file: $src2\n");
|
|---|
| 1637 |
|
|---|
| 1638 | pb_log(2,"Working directory: $ENV{'PBBUILDDIR'}\n");
|
|---|
| 1639 | if ($pbos->{'type'} eq "rpm") {
|
|---|
| 1640 | # Remove in case a previous link/file was there
|
|---|
| 1641 | unlink "$ENV{'PBBUILDDIR'}/SOURCES/".basename($src);
|
|---|
| 1642 | symlink "$src","$ENV{'PBBUILDDIR'}/SOURCES/".basename($src) || die "Unable to symlink $src in $ENV{'PBBUILDDIR'}/SOURCES";
|
|---|
| 1643 | # We need to first extract the spec file
|
|---|
| 1644 | my @specfile = pb_extract_build_files($src2,"$pbpkg-$pbver$pbextdir/pbconf/$pbos->{'name'}-$pbos->{'version'}-$pbos->{'arch'}/","$ENV{'PBBUILDDIR'}/SPECS","spec");
|
|---|
| 1645 |
|
|---|
| 1646 | # We need to handle potential patches to upstream sources
|
|---|
| 1647 | pb_extract_build_files($src2,"$pbpkg-$pbver$pbextdir/pbconf/$pbos->{'name'}-$pbos->{'version'}-$pbos->{'arch'}/pbpatch/","$ENV{'PBBUILDDIR'}/SOURCES","patch");
|
|---|
| 1648 |
|
|---|
| 1649 | # We need to handle potential additional sources to upstream sources
|
|---|
| 1650 | pb_extract_build_files($src2,"$pbpkg-$pbver$pbextdir/pbconf/$pbos->{'name'}-$pbos->{'version'}-$pbos->{'arch'}/pbsrc/","$ENV{'PBBUILDDIR'}/SOURCES","src");
|
|---|
| 1651 |
|
|---|
| 1652 | pb_log(2,"specfile: ".Dumper(\@specfile)."\n");
|
|---|
| 1653 | # set LANGUAGE to check for correct log messages
|
|---|
| 1654 | $ENV{'LANGUAGE'}="C";
|
|---|
| 1655 | # Older Redhat use _target_platform in %configure incorrectly
|
|---|
| 1656 | my $specialdef = "";
|
|---|
| 1657 | if (($pbos->{'name'} eq "rhel") && ($pbos->{'version'} eq "2.1")) {
|
|---|
| 1658 | $specialdef = "--define \'_target_platform \"\"\'";
|
|---|
| 1659 | }
|
|---|
| 1660 | my $buildcmd = "rpmbuild";
|
|---|
| 1661 | if (($pbos->{'name'} eq "redhat") && ($pbos->{'version'} =~ /^6/)){
|
|---|
| 1662 | $buildcmd = "rpm" ;
|
|---|
| 1663 | }
|
|---|
| 1664 |
|
|---|
| 1665 | foreach my $f (@specfile) {
|
|---|
| 1666 | if ($f =~ /\.spec$/) {
|
|---|
| 1667 | pb_system("$buildcmd $specialdef --define \"packager $ENV{'PBPACKAGER'}\" --define \"_topdir $ENV{'PBBUILDDIR'}\" -ba $f","Building package with $f under $ENV{'PBBUILDDIR'}","verbose");
|
|---|
| 1668 | last;
|
|---|
| 1669 | }
|
|---|
| 1670 | }
|
|---|
| 1671 | # Get the name of the generated packages
|
|---|
| 1672 | open(LOG,"$ENV{'PBTMP'}/system.$$.log") || die "Unable to open $ENV{'PBTMP'}/system.$$.log";
|
|---|
| 1673 | while (<LOG>) {
|
|---|
| 1674 | chomp($_);
|
|---|
| 1675 | next if ($_ !~ /^Wrote:/);
|
|---|
| 1676 | s|.*/([S]*RPMS.*)|$1|;
|
|---|
| 1677 | $made .=" $_";
|
|---|
| 1678 | }
|
|---|
| 1679 | close(LOG);
|
|---|
| 1680 |
|
|---|
| 1681 | } elsif ($pbos->{'type'} eq "deb") {
|
|---|
| 1682 | pb_system("tar xfz $src","Extracting sources");
|
|---|
| 1683 | pb_system("tar xfz $src2","Extracting pbconf");
|
|---|
| 1684 |
|
|---|
| 1685 | chdir "$pbpkg-$pbver$pbextdir" || die "Unable to chdir to $pbpkg-$pbver$pbextdir";
|
|---|
| 1686 | pb_rm_rf("debian");
|
|---|
| 1687 | my $confdir = "pbconf/$pbos->{'name'}-$pbos->{'version'}-$pbos->{'arch'}";
|
|---|
| 1688 | die "Configuration directory $confdir is not a directory\nIs os description listed in your {ve,vm,rm}list values?" if (not -d $confdir);
|
|---|
| 1689 | symlink "$confdir","debian" || die "Unable to symlink 'debian' to $confdir";
|
|---|
| 1690 | chmod 0755,"debian/rules";
|
|---|
| 1691 |
|
|---|
| 1692 | # We need to handle potential patches to upstream sources
|
|---|
| 1693 | pb_mkdir_p("debian/patches");
|
|---|
| 1694 | my @f = pb_extract_build_files($src2,"$pbpkg-$pbver$pbextdir/pbconf/$pbos->{'name'}-$pbos->{'version'}-$pbos->{'arch'}/pbpatch/","debian/patches","patch");
|
|---|
| 1695 |
|
|---|
| 1696 | # By default we use format 1.0 - Cf man dpkg-source
|
|---|
| 1697 | my $debsrcfmt = "1.0";
|
|---|
| 1698 | my $debsrcfile = "debian/source/format";
|
|---|
| 1699 | if (-f $debsrcfile) {
|
|---|
| 1700 | $debsrcfmt = pb_get_content($debsrcfile);
|
|---|
| 1701 | }
|
|---|
| 1702 |
|
|---|
| 1703 | if ($debsrcfmt =~ /^3.*quilt/) {
|
|---|
| 1704 | # If we use quilt to manage patches, we then setup the env correctly
|
|---|
| 1705 | # as per http://pkg-perl.alioth.debian.org/howto/quilt.html
|
|---|
| 1706 | # Generate Debian patch series for quilt
|
|---|
| 1707 | open(SERIE,"> debian/patches/series") || die "Unable to write in debian/patches/series";
|
|---|
| 1708 | $ENV{'QUILT_PATCHES'}="debian/patches";
|
|---|
| 1709 | } else {
|
|---|
| 1710 | # If we use dpatch to manage patches, we then setup the 00list file as well
|
|---|
| 1711 | open(SERIE,"> debian/patches/00list") || die "Unable to write in debian/patches/00list";
|
|---|
| 1712 | }
|
|---|
| 1713 | foreach my $f (sort @f) {
|
|---|
| 1714 | # Skip the script made to apply the patches to the Debian tree
|
|---|
| 1715 | next if ($f =~ /pbapplypatch/);
|
|---|
| 1716 | # We also need to uncompress them
|
|---|
| 1717 | pb_system("gzip -d $f","","quiet");
|
|---|
| 1718 | $f =~ s/\.gz$//;
|
|---|
| 1719 | print SERIE "$f\n";
|
|---|
| 1720 | }
|
|---|
| 1721 | close(SERIE);
|
|---|
| 1722 | if (@f) {
|
|---|
| 1723 | # We have patches...
|
|---|
| 1724 | my $patch_file = "debian/patches/pbapplypatch";
|
|---|
| 1725 | if (($debsrcfmt =~ /^1.*/) && (-x $patch_file)) {
|
|---|
| 1726 | # In that case we need to apply the patches ourselves locally
|
|---|
| 1727 | pb_system("cat $patch_file","APPLY","verbose");
|
|---|
| 1728 | pb_system("$patch_file","Applying patches to $pbos->{'name'}-$pbos->{'version'}-$pbos->{'arch'} tree");
|
|---|
| 1729 | }
|
|---|
| 1730 | # ...so modify the name of files to be Debian compliant
|
|---|
| 1731 | move("../$src","../$pbpkg-$pbver$pbextdir.orig.tar.gz");
|
|---|
| 1732 | }
|
|---|
| 1733 |
|
|---|
| 1734 | # We need to handle potential additional sources to upstream sources
|
|---|
| 1735 | #pb_extract_build_files($src2,"$pbpkg-$pbver$pbextdir/pbconf/$pbos->{'name'}-$pbos->{'version'}-$pbos->{'arch'}/pbsrc/","$ENV{'PBBUILDDIR'}/debian","src");
|
|---|
| 1736 |
|
|---|
| 1737 | pb_system("dpkg-buildpackage -us -uc -rfakeroot","Building package","verbose");
|
|---|
| 1738 |
|
|---|
| 1739 | # Get the name of the generated packages
|
|---|
| 1740 | open(LOG,"$ENV{'PBTMP'}/system.$$.log") || die "Unable to open $ENV{'PBTMP'}/system.$$.log";
|
|---|
| 1741 | while (<LOG>) {
|
|---|
| 1742 | chomp();
|
|---|
| 1743 | pb_log(3,"In loop: $_\n");
|
|---|
| 1744 | next unless (/^dpkg-deb.*\.\.\/(.*_.*\.deb).*/);
|
|---|
| 1745 | my $tmp = $1;
|
|---|
| 1746 | #doesn't work in my case
|
|---|
| 1747 | #die "Missing file $tmp" if (not -f "../$tmp");
|
|---|
| 1748 | $made = "$made $tmp";
|
|---|
| 1749 | }
|
|---|
| 1750 | close(LOG);
|
|---|
| 1751 | pb_log(2,"Now made is: $made\n");
|
|---|
| 1752 |
|
|---|
| 1753 | open(CTRL,"debian/control") || die "Unable to open debian/control: $!";
|
|---|
| 1754 | while (<CTRL>) {
|
|---|
| 1755 | pb_log(3,"In loop: $_\n");
|
|---|
| 1756 | next unless (/^Source: (\S+)/o);
|
|---|
| 1757 | my $tmp = $1;
|
|---|
| 1758 | $made = "$made $tmp"."_*.dsc $tmp"."_*.tar.gz $tmp"."_*.changes";
|
|---|
| 1759 | #doesn't work in my case
|
|---|
| 1760 | #foreach my $glob (("$1\_*.changes", "$1\_*.dsc", "$1\_*.tar.gz")) {
|
|---|
| 1761 | #my @file = glob($glob);
|
|---|
| 1762 | #die "Missing file for $glob" unless (@file > 0);
|
|---|
| 1763 | #die "Too many files for $glob" if (@file > 1);
|
|---|
| 1764 | #die "Missing file $file[0]" if (not -f $file[0]);
|
|---|
| 1765 | #$made .= " $file[0]";
|
|---|
| 1766 | #}
|
|---|
| 1767 | }
|
|---|
| 1768 | close(CTRL);
|
|---|
| 1769 | #pb_display_file("$ENV{'PBTMP'}/system.$$.log");
|
|---|
| 1770 | pb_log(2,"Finally made is: $made\n");
|
|---|
| 1771 |
|
|---|
| 1772 | chdir ".." || die "Unable to chdir to parent dir";
|
|---|
| 1773 | pb_rm_rf("$pbpkg-$pbver$pbextdir");
|
|---|
| 1774 | } elsif ($pbos->{'type'} eq "ebuild") {
|
|---|
| 1775 | my @ebuildfile;
|
|---|
| 1776 | # For gentoo we need to take pb as subsystem name
|
|---|
| 1777 | # We put every apps here under sys-apps. hope it's correct
|
|---|
| 1778 | # We use pb's home dir in order to have a single OVERLAY line
|
|---|
| 1779 | my $tmpe = "$ENV{'HOME'}/portage/pb/sys-apps/$pbpkg";
|
|---|
| 1780 | pb_mkdir_p($tmpe) if (! -d "$tmpe");
|
|---|
| 1781 | pb_mkdir_p("$ENV{'HOME'}/portage/distfiles") if (! -d "$ENV{'HOME'}/portage/distfiles");
|
|---|
| 1782 |
|
|---|
| 1783 | # We need to first extract the ebuild file
|
|---|
| 1784 | @ebuildfile = pb_extract_build_files($src2,"$pbpkg-$pbver$pbextdir/pbconf/$pbos->{'name'}-$pbos->{'version'}-$pbos->{'arch'}/","$tmpe","ebuild");
|
|---|
| 1785 |
|
|---|
| 1786 | # Prepare the build env for gentoo
|
|---|
| 1787 | my $found = 0;
|
|---|
| 1788 | my $pbbd = $ENV{'HOME'};
|
|---|
| 1789 | $pbbd =~ s|/|\\/|g;
|
|---|
| 1790 | if (-r "/etc/make.conf") {
|
|---|
| 1791 | open(MAKE,"/etc/make.conf");
|
|---|
| 1792 | while (<MAKE>) {
|
|---|
| 1793 | $found = 1 if (/$pbbd\/portage/);
|
|---|
| 1794 | }
|
|---|
| 1795 | close(MAKE);
|
|---|
| 1796 | }
|
|---|
| 1797 | if ($found == 0) {
|
|---|
| 1798 | pb_system("sudo sh -c 'echo PORTDIR_OVERLAY=\"$ENV{'HOME'}/portage\" >> /etc/make.conf'");
|
|---|
| 1799 | }
|
|---|
| 1800 | #$found = 0;
|
|---|
| 1801 | #if (-r "/etc/portage/package.keywords") {
|
|---|
| 1802 | #open(KEYW,"/etc/portage/package.keywords");
|
|---|
| 1803 | #while (<KEYW>) {
|
|---|
| 1804 | #$found = 1 if (/portage\/pb/);
|
|---|
| 1805 | #}
|
|---|
| 1806 | #close(KEYW);
|
|---|
| 1807 | #}
|
|---|
| 1808 | #if ($found == 0) {
|
|---|
| 1809 | #pb_system("sudo sh -c \"echo portage/pb >> /etc/portage/package.keywords\"");
|
|---|
| 1810 | #}
|
|---|
| 1811 |
|
|---|
| 1812 | # Build
|
|---|
| 1813 | foreach my $f (@ebuildfile) {
|
|---|
| 1814 | if ($f =~ /\.ebuild$/) {
|
|---|
| 1815 | move($f,"$tmpe/$pbpkg-$pbver.ebuild");
|
|---|
| 1816 | pb_system("cd $tmpe ; ebuild $pbpkg-$pbver.ebuild clean ; ebuild $pbpkg-$pbver.ebuild digest ; ebuild $pbpkg-$pbver.ebuild package","verbose");
|
|---|
| 1817 | # Now move it where pb expects it
|
|---|
| 1818 | pb_mkdir_p("$ENV{'PBBUILDDIR'}/portage/pb/sys-apps/$pbpkg");
|
|---|
| 1819 | if ($pbtag eq 0) {
|
|---|
| 1820 | # This is assumed to be a test version
|
|---|
| 1821 | my $nver = substr($pbver,0,-14);
|
|---|
| 1822 | my $ntag = substr($pbver,-14);
|
|---|
| 1823 | my $ebtg = "portage/pb/sys-apps/$pbpkg/$pbpkg-$nver"."_p$ntag.ebuild";
|
|---|
| 1824 | move("$tmpe/$pbpkg-$pbver.ebuild","$ENV{'PBBUILDDIR'}/$ebtg");
|
|---|
| 1825 | $made="$made $ebtg";
|
|---|
| 1826 | } else {
|
|---|
| 1827 | my $ebtg = "portage/pb/sys-apps/$pbpkg/$pbpkg-$pbver-r$pbtag.ebuild";
|
|---|
| 1828 | move("$tmpe/$pbpkg-$pbver.ebuild","$ENV{'PBBUILDDIR'}/$ebtg");
|
|---|
| 1829 | $made="$made $ebtg";
|
|---|
| 1830 | }
|
|---|
| 1831 | }
|
|---|
| 1832 | }
|
|---|
| 1833 |
|
|---|
| 1834 | } elsif ($pbos->{'type'} eq "tgz") {
|
|---|
| 1835 | # Slackware family
|
|---|
| 1836 | $made="$made $pbpkg/$pbpkg-$pbver-*-$pbtag.tgz";
|
|---|
| 1837 |
|
|---|
| 1838 | pb_system("tar xfz $src","Extracting sources");
|
|---|
| 1839 | pb_system("tar xfz $src2","Extracting pbconf");
|
|---|
| 1840 | chdir "$pbpkg-$pbver$pbextdir" || die "Unable to chdir to $pbpkg-$pbver$pbextdir";
|
|---|
| 1841 | symlink "pbconf/$pbos->{'name'}-$pbos->{'version'}-$pbos->{'arch'}","install" || die "Unable to symlink to pbconf/$pbos->{'name'}-$pbos->{'version'}-$pbos->{'arch'}";
|
|---|
| 1842 | if (-x "install/pbslack") {
|
|---|
| 1843 | pb_system("./install/pbslack","Building software");
|
|---|
| 1844 | pb_system("sudo /sbin/makepkg -p -l y -c y $pbpkg","Packaging $pbpkg","verbose");
|
|---|
| 1845 | }
|
|---|
| 1846 | chdir ".." || die "Unable to chdir to parent dir";
|
|---|
| 1847 | pb_rm_rf("$pbpkg-$pbver$pbextdir");
|
|---|
| 1848 | } elsif ($pbos->{'type'} eq "pkg") {
|
|---|
| 1849 | # Solaris
|
|---|
| 1850 | $made="$made $pbpkg-$pbver-$pbtag.pkg.gz";
|
|---|
| 1851 | my $pkgdestdir="$ENV{'PBBUILDDIR'}/install";
|
|---|
| 1852 |
|
|---|
| 1853 | # Will host resulting packages
|
|---|
| 1854 | pb_mkdir_p("$pbos->{'type'}");
|
|---|
| 1855 | pb_mkdir_p("$pkgdestdir/pbdelivery");
|
|---|
| 1856 | pb_system("tar xfz $src","Extracting sources under $ENV{'PBBUILDDIR'}");
|
|---|
| 1857 | pb_system("tar xfz $src2","Extracting pbconf under $ENV{'PBBUILDDIR'}");
|
|---|
| 1858 | # We need to handle potential patches to upstream sources
|
|---|
| 1859 | pb_extract_build_files($src2,"$pbpkg-$pbver$pbextdir/pbconf/$pbos->{'name'}-$pbos->{'version'}-$pbos->{'arch'}/pbpatch/","$ENV{'PBBUILDDIR'}","patch");
|
|---|
| 1860 |
|
|---|
| 1861 | # We need to handle potential additional sources to upstream sources
|
|---|
| 1862 | pb_extract_build_files($src2,"$pbpkg-$pbver$pbextdir/pbconf/$pbos->{'name'}-$pbos->{'version'}-$pbos->{'arch'}/pbsrc/","$ENV{'PBBUILDDIR'}","src");
|
|---|
| 1863 |
|
|---|
| 1864 | chdir "$pbpkg-$pbver$pbextdir" || die "Unable to chdir to $pbpkg-$pbver$pbextdir";
|
|---|
| 1865 | if (-f "pbconf/$pbos->{'name'}-$pbos->{'version'}-$pbos->{'arch'}/pbbuild") {
|
|---|
| 1866 | chmod 0755,"pbconf/$pbos->{'name'}-$pbos->{'version'}-$pbos->{'arch'}/pbbuild";
|
|---|
| 1867 | # pkginfo file is mandatory
|
|---|
| 1868 | die "Unable to find pkginfo file in pbconf/$pbos->{'name'}-$pbos->{'version'}-$pbos->{'arch'}" if (! -f "pbconf/$pbos->{'name'}-$pbos->{'version'}-$pbos->{'arch'}/pkginfo");
|
|---|
| 1869 | # Build
|
|---|
| 1870 | pb_system("pbconf/$pbos->{'name'}-$pbos->{'version'}-$pbos->{'arch'}/pbbuild $pkgdestdir/pbdelivery","Building software and installing under $pkgdestdir/pbdelivery");
|
|---|
| 1871 | # Copy complementary files
|
|---|
| 1872 | if (-f "pbconf/$pbos->{'name'}-$pbos->{'version'}-$pbos->{'arch'}/prototype") {
|
|---|
| 1873 | copy("pbconf/$pbos->{'name'}-$pbos->{'version'}-$pbos->{'arch'}/prototype", $pkgdestdir)
|
|---|
| 1874 | } else {
|
|---|
| 1875 | # No prototype provided, calculating it
|
|---|
| 1876 | open(PROTO,"> $pkgdestdir/prototype") || die "Unable to create prototype file";
|
|---|
| 1877 | print PROTO "i pkginfo\n";
|
|---|
| 1878 | print PROTO "i depend\n" if (-f "pbconf/$pbos->{'name'}-$pbos->{'version'}-$pbos->{'arch'}/depend");
|
|---|
| 1879 | $ENV{'PBSOLDESTDIR'} = "$pkgdestdir/pbdelivery";
|
|---|
| 1880 | find(\&create_solaris_prototype, "$pkgdestdir/pbdelivery");
|
|---|
| 1881 | }
|
|---|
| 1882 | copy("pbconf/$pbos->{'name'}-$pbos->{'version'}-$pbos->{'arch'}/depend", $pkgdestdir) if (-f "pbconf/$pbos->{'name'}-$pbos->{'version'}-$pbos->{'arch'}/depend");
|
|---|
| 1883 | copy("pbconf/$pbos->{'name'}-$pbos->{'version'}-$pbos->{'arch'}/pkginfo", $pkgdestdir);
|
|---|
| 1884 | pb_system("cd $pkgdestdir/pbdelivery ; pkgmk -o -f ../prototype -r $pkgdestdir/pbdelivery -d $ENV{'PBBUILDDIR'}/$pbos->{'type'}","Packaging $pbpkg","verbose");
|
|---|
| 1885 | pb_system("cd $ENV{'PBBUILDDIR'}/$pbos->{'type'} ; echo \"\" | pkgtrans -o -n -s $ENV{'PBBUILDDIR'}/$pbos->{'type'} $ENV{'PBBUILDDIR'}/$pbpkg-$pbver-$pbtag.pkg all","Transforming $pbpkg","verbose");
|
|---|
| 1886 | pb_system("cd $ENV{'PBBUILDDIR'} ; gzip -9f $pbpkg-$pbver-$pbtag.pkg","Compressing $pbpkg-$pbver-$pbtag.pkg","verbose");
|
|---|
| 1887 | } else {
|
|---|
| 1888 | pb_log(0,"No pbconf/$pbos->{'name'}-$pbos->{'version'}-$pbos->{'arch'}/pbbuild file found for $pbpkg-$pbver in \n");
|
|---|
| 1889 | }
|
|---|
| 1890 | chdir ".." || die "Unable to chdir to parent dir";
|
|---|
| 1891 | pb_rm_rf("$pbpkg-$pbver$pbextdir","$ENV{'PBBUILDDIR'}/$pbos->{'type'}","$pkgdestdir");
|
|---|
| 1892 | } elsif ($pbos->{'type'} eq "hpux") {
|
|---|
| 1893 | # HP-UX
|
|---|
| 1894 | pb_system("tar xfz $src","Extracting sources");
|
|---|
| 1895 | pb_system("tar xfz $src2","Extracting pbconf");
|
|---|
| 1896 |
|
|---|
| 1897 | chdir "$pbpkg-$pbver$pbextdir" || die "Unable to chdir to $pbpkg-$pbver$pbextdir";
|
|---|
| 1898 | pb_system("buildpackage ","Building package","verbose");
|
|---|
| 1899 | # Get the name of the generated packages
|
|---|
| 1900 | open(LOG,"$ENV{'PBTMP'}/system.$$.log") || die "Unable to open $ENV{'PBTMP'}/system.$$.log";
|
|---|
| 1901 | while (<LOG>) {
|
|---|
| 1902 | chomp();
|
|---|
| 1903 | my $tmp = $_;
|
|---|
| 1904 | next if ($tmp !~ /^SD BUILD.*:/);
|
|---|
| 1905 | $tmp =~ s|.*../(.*)_(.*).sd.*|$1|;
|
|---|
| 1906 | $made = "$made $tmp"."_*.sd";
|
|---|
| 1907 | }
|
|---|
| 1908 | close(LOG);
|
|---|
| 1909 | $made="$made $pbpkg-$pbver-$pbtag.sd";
|
|---|
| 1910 |
|
|---|
| 1911 | chdir ".." || die "Unable to chdir to parent dir";
|
|---|
| 1912 | pb_rm_rf("$pbpkg-$pbver$pbextdir");
|
|---|
| 1913 | } else {
|
|---|
| 1914 | die "Unknown OS type format $pbos->{'type'}";
|
|---|
| 1915 | }
|
|---|
| 1916 | if (defined $pbparallel) {
|
|---|
| 1917 | # Communicate results back to parent
|
|---|
| 1918 | pb_set_content("$tmpd/$$",$made);
|
|---|
| 1919 | $pm->finish;
|
|---|
| 1920 | }
|
|---|
| 1921 | }
|
|---|
| 1922 | if (defined $pbparallel) {
|
|---|
| 1923 | # In the parent, we need to get the result from the children
|
|---|
| 1924 | $pm->wait_all_children;
|
|---|
| 1925 | foreach my $f (<$tmpd/*>) {
|
|---|
| 1926 | $made .= " ".pb_get_content($f);
|
|---|
| 1927 | }
|
|---|
| 1928 | die "Aborting, one or more of the children failed." if ((not $all_ok) && ($Global::pb_stop_on_error));
|
|---|
| 1929 | pb_rm_rf($tmpd);
|
|---|
| 1930 | }
|
|---|
| 1931 |
|
|---|
| 1932 | # Sign packages
|
|---|
| 1933 | pb_sign_pkgs($pbos,$made);
|
|---|
| 1934 | pb_log(0,"INFO: ------ Finished building package ------\n");
|
|---|
| 1935 |
|
|---|
| 1936 | # Find the appropriate check cmd/opts
|
|---|
| 1937 | my ($chkcmd,$chkopt) = pb_distro_get_param($pbos,pb_conf_get_if("oschkcmd","oschkopt"));
|
|---|
| 1938 |
|
|---|
| 1939 | my $ret = "";
|
|---|
| 1940 | # Packages check if needed
|
|---|
| 1941 | if ($pbos->{'type'} eq "rpm") {
|
|---|
| 1942 | if ((defined $chkcmd) && (-x $chkcmd)) {
|
|---|
| 1943 | my $cmd = "$chkcmd";
|
|---|
| 1944 | $cmd .= " $chkopt" if (defined $chkopt);
|
|---|
| 1945 | $cmd .= " $made";
|
|---|
| 1946 | my $ret = pb_system("$cmd","Checking validity of rpms with $chkcmd","mayfailverbose");
|
|---|
| 1947 | pb_log(0,"ERROR: when checking packages validity\n") if ($ret ne 0);
|
|---|
| 1948 | }
|
|---|
| 1949 | my $rpms ="";
|
|---|
| 1950 | my $srpms ="";
|
|---|
| 1951 | foreach my $f (split(/ /,$made)) {
|
|---|
| 1952 | $rpms .= "$ENV{'PBBUILDDIR'}/$f " if ($f =~ /^RPMS\//);
|
|---|
| 1953 | $srpms .= "$ENV{'PBBUILDDIR'}/$f " if ($f =~ /^SRPMS\//);
|
|---|
| 1954 | }
|
|---|
| 1955 | pb_log(0,"SRPM packages generated: $srpms\n");
|
|---|
| 1956 | pb_log(0,"RPM packages generated: $rpms\n");
|
|---|
| 1957 | $ret = $rpms;
|
|---|
| 1958 | } elsif ($pbos->{'type'} eq "deb") {
|
|---|
| 1959 | my $made2 = "";
|
|---|
| 1960 | foreach my $f (split(/ /,$made)) {
|
|---|
| 1961 | $made2 .= "$f " if ($f =~ /\.deb$/);
|
|---|
| 1962 | }
|
|---|
| 1963 | if ((defined $chkcmd) && (-x $chkcmd)) {
|
|---|
| 1964 | my $ret = pb_system("$chkcmd $chkopt $made2","Checking validity of debs with $chkcmd","mayfail");
|
|---|
| 1965 | pb_log(0,"ERROR: when checking packages validity\n") if ($ret ne 0);
|
|---|
| 1966 | }
|
|---|
| 1967 | pb_log(0,"deb packages generated: $made2\n");
|
|---|
| 1968 | $ret = $made2;
|
|---|
| 1969 | } else {
|
|---|
| 1970 | pb_log(0,"No check done for $pbos->{'type'} yet\n");
|
|---|
| 1971 | pb_log(0,"Packages generated: $made\n");
|
|---|
| 1972 | $ret = $made;
|
|---|
| 1973 | }
|
|---|
| 1974 |
|
|---|
| 1975 | # Keep track of what is generated so that we can get them back from VMs/RMs
|
|---|
| 1976 | my $pbstore = "$ENV{'PBBUILDDIR'}/pbgen-$ENV{'PBPROJVER'}-$ENV{'PBPROJTAG'}-$pbos->{'name'}-$pbos->{'version'}-$pbos->{'arch'}";
|
|---|
| 1977 | open(KEEP,"> $pbstore") || die "Unable to create $pbstore $!";
|
|---|
| 1978 | print KEEP "$made\n";
|
|---|
| 1979 | close(KEEP);
|
|---|
| 1980 | pb_distro_installdeps(undef,$pbos,$ret) if ($do_install);
|
|---|
| 1981 | }
|
|---|
| 1982 |
|
|---|
| 1983 | sub pb_build2ssh {
|
|---|
| 1984 | pb_send2target("Sources");
|
|---|
| 1985 | pb_send2target("CPAN");
|
|---|
| 1986 | }
|
|---|
| 1987 |
|
|---|
| 1988 | sub pb_pkg2ssh {
|
|---|
| 1989 | pb_send2target("Packages");
|
|---|
| 1990 | }
|
|---|
| 1991 |
|
|---|
| 1992 | # By default deliver to the the public site hosting the
|
|---|
| 1993 | # ftp structure (or whatever) or a VM/VE/RM
|
|---|
| 1994 | sub pb_send2target {
|
|---|
| 1995 |
|
|---|
| 1996 | my $cmt = shift;
|
|---|
| 1997 | my $pbscript1 = shift;
|
|---|
| 1998 | my $v = shift;
|
|---|
| 1999 | my $vexist = shift; # 0 is FALSE
|
|---|
| 2000 | my $vpid = shift; # 0 is FALSE
|
|---|
| 2001 | my $snapme = shift; # 0 is FALSE
|
|---|
| 2002 | my $pbstep = shift; # 3 is usage of container
|
|---|
| 2003 |
|
|---|
| 2004 | $vexist = 0 if (not defined $vexist);
|
|---|
| 2005 | $vpid = 0 if (not defined $vpid);
|
|---|
| 2006 | $snapme = 0 if (not defined $snapme);
|
|---|
| 2007 | $pbstep = 3 if (not defined $pbstep);
|
|---|
| 2008 | pb_log(2,"DEBUG: pb_send2target($cmt,".Dumper($v).",$vexist,$vpid)\n");
|
|---|
| 2009 | my $host = "sshhost";
|
|---|
| 2010 | my $login = "sshlogin";
|
|---|
| 2011 | my $dir = "sshdir";
|
|---|
| 2012 | my $port = "sshport";
|
|---|
| 2013 | my $conf = "sshconf";
|
|---|
| 2014 | my $tmout = undef;
|
|---|
| 2015 | my $path = undef;
|
|---|
| 2016 |
|
|---|
| 2017 | if ($cmt =~ /^VM/) {
|
|---|
| 2018 | $login = "vmlogin";
|
|---|
| 2019 | $dir = "pbdefdir";
|
|---|
| 2020 | # Specific VM
|
|---|
| 2021 | $tmout = "vmtmout";
|
|---|
| 2022 | $path = "vmpath";
|
|---|
| 2023 | $host = "vmhost";
|
|---|
| 2024 | $port = "vmport";
|
|---|
| 2025 | } elsif ($cmt =~ /^RM/) {
|
|---|
| 2026 | $login = "rmlogin";
|
|---|
| 2027 | $dir = "pbdefdir";
|
|---|
| 2028 | # Specific RM
|
|---|
| 2029 | $tmout = "rmtmout";
|
|---|
| 2030 | $path = "rmpath";
|
|---|
| 2031 | $host = "rmhost";
|
|---|
| 2032 | $port = "rmport";
|
|---|
| 2033 | } elsif ($cmt =~ /^VE/) {
|
|---|
| 2034 | $login = "velogin";
|
|---|
| 2035 | $dir = "pbdefdir";
|
|---|
| 2036 | # Specific VE
|
|---|
| 2037 | $path = "vepath";
|
|---|
| 2038 | $conf = "rbsconf";
|
|---|
| 2039 | } elsif ($cmt eq "Web") {
|
|---|
| 2040 | $host = "websshhost";
|
|---|
| 2041 | $login = "websshlogin";
|
|---|
| 2042 | $dir = "websshdir";
|
|---|
| 2043 | $port = "websshport";
|
|---|
| 2044 | } elsif ($cmt eq "CPAN") {
|
|---|
| 2045 | $host = "cpanpause";
|
|---|
| 2046 | $login = "";
|
|---|
| 2047 | $dir = "cpandir";
|
|---|
| 2048 | $port = "";
|
|---|
| 2049 | }
|
|---|
| 2050 | my $cmd = "";
|
|---|
| 2051 | my $src = "";
|
|---|
| 2052 | my $cpanpkg = 0;
|
|---|
| 2053 | my $pbos;
|
|---|
| 2054 |
|
|---|
| 2055 | my $pbextdir = pb_get_extdir();
|
|---|
| 2056 |
|
|---|
| 2057 | if ($cmt ne "Announce") {
|
|---|
| 2058 | # Get list of packages to build
|
|---|
| 2059 | my $ptr = pb_get_pkg();
|
|---|
| 2060 | my @pkgs = ();
|
|---|
| 2061 | @pkgs = @$ptr if (defined $ptr);
|
|---|
| 2062 |
|
|---|
| 2063 | # Get the running distro to consider
|
|---|
| 2064 | $pbos = pb_distro_get_context($v);
|
|---|
| 2065 |
|
|---|
| 2066 | my $pkg = { };
|
|---|
| 2067 | # Get content saved in cms2build
|
|---|
| 2068 | if ((defined $ENV{'PBDESTDIR'}) && (defined $ENV{'PBPROJVER'}) && (defined $ENV{'PBPROJTAG'}) && (-f "$ENV{'PBDESTDIR'}/$ENV{'PBPROJVER'}-$ENV{'PBPROJTAG'}.pb")) {
|
|---|
| 2069 | ($pkg) = pb_conf_read("$ENV{'PBDESTDIR'}/$ENV{'PBPROJVER'}-$ENV{'PBPROJTAG'}.pb","pbpkg");
|
|---|
| 2070 | $pkg = { } if (not defined $pkg);
|
|---|
| 2071 | }
|
|---|
| 2072 |
|
|---|
| 2073 | pb_mkdir_p("$ENV{'PBBUILDDIR'}") if (! -d "$ENV{'PBBUILDDIR'}");
|
|---|
| 2074 | chdir "$ENV{'PBBUILDDIR'}" || die "Unable to chdir to $ENV{'PBBUILDDIR'}";
|
|---|
| 2075 | foreach my $pbpkg (@pkgs) {
|
|---|
| 2076 | my $vertag = $pkg->{$pbpkg};
|
|---|
| 2077 | # get the version of the current package - maybe different
|
|---|
| 2078 | pb_log(2,"Vertag: $vertag\n");
|
|---|
| 2079 | ($pbver,$pbtag) = split(/-/,$vertag);
|
|---|
| 2080 |
|
|---|
| 2081 | if (($cmt eq "Sources") || ($cmt =~ /(V[EM]|RM)(build|prep)/)) {
|
|---|
| 2082 | $src = "$src $ENV{'PBDESTDIR'}/$pbpkg-$pbver$pbextdir.tar.gz $ENV{'PBDESTDIR'}/$pbpkg-$pbver$pbextdir.pbconf.tar.gz";
|
|---|
| 2083 | my $cmd2 = "ln -sf $pbpkg-$pbver$pbextdir.tar.gz $pbpkg-latest.tar.gz";
|
|---|
| 2084 | #my $cmd2 = "ln $pbpkg-$pbver$pbextdir.tar.gz $pbpkg-latest.tar.gz 2> /dev/null ; if [ \$? -ne 0 ]; then ln -sf $pbpkg-$pbver$pbextdir.tar.gz $pbpkg-latest.tar.gz ; fi";
|
|---|
| 2085 | if ($cmd eq "") {
|
|---|
| 2086 | $cmd = $cmd2;
|
|---|
| 2087 | } else {
|
|---|
| 2088 | $cmd = "$cmd ; $cmd2";
|
|---|
| 2089 | }
|
|---|
| 2090 | } elsif ($cmt eq "Web") {
|
|---|
| 2091 | $src = "$src $ENV{'PBDESTDIR'}/$pbpkg-$pbver$pbextdir.tar.gz"
|
|---|
| 2092 | }
|
|---|
| 2093 |
|
|---|
| 2094 | # Do we have one perl package
|
|---|
| 2095 | my @nametype = pb_conf_get_if("namingtype");
|
|---|
| 2096 | my $type = $nametype[0]->{$pbpkg};
|
|---|
| 2097 | if ((defined $type) && ($type eq "perl")) {
|
|---|
| 2098 | $cpanpkg = 1;
|
|---|
| 2099 | }
|
|---|
| 2100 | }
|
|---|
| 2101 | # Adds conf file for availability of conf elements
|
|---|
| 2102 | pb_conf_add("$ENV{'PBROOTDIR'}/$ENV{'PBPROJ'}.pb") if ((defined $ENV{'PBROOTDIR'}) && (-f "$ENV{'PBROOTDIR'}/$ENV{'PBPROJ'}.pb"));
|
|---|
| 2103 | }
|
|---|
| 2104 | my ($rbsconf,$testver,$delivery) = pb_conf_get_if($conf,"testver","delivery");
|
|---|
| 2105 | if ($cmt eq "CPAN") {
|
|---|
| 2106 | # Do not deliver on Pause if this is a test version
|
|---|
| 2107 | return if (not defined $testver);
|
|---|
| 2108 | return if ($testver =~ /true/);
|
|---|
| 2109 | # Do not deliver on Pause if this is not a perl package
|
|---|
| 2110 | return if ($cpanpkg == 0);
|
|---|
| 2111 | }
|
|---|
| 2112 |
|
|---|
| 2113 | if ($cmt =~ /(V[EM]|RM)(build|prep)/) {
|
|---|
| 2114 | $src="$src $ENV{'PBROOTDIR'}/$ENV{'PBPROJ'}.pb $ENV{'PBDESTDIR'}/$ENV{'PBPROJVER'}-$ENV{'PBPROJTAG'}.pb $ENV{'PBETC'} $ENV{'PBDESTDIR'}/pbrc $pbscript{$v}";
|
|---|
| 2115 | } elsif ($cmt =~ /(V[EM]|RM)Script/) {
|
|---|
| 2116 | $src="$src $pbscript{$v}";
|
|---|
| 2117 | } elsif ($cmt =~ /(V[EM]|RM)test/) {
|
|---|
| 2118 | $src="$src $ENV{'PBROOTDIR'}/$ENV{'PBPROJ'}.pb $ENV{'PBDESTDIR'}/$ENV{'PBPROJVER'}-$ENV{'PBPROJTAG'}.pb $ENV{'PBETC'} $ENV{'PBDESTDIR'}/pbrc $pbscript{$v} $ENV{'PBDESTDIR'}/pbtest";
|
|---|
| 2119 | } elsif (($cmt eq "Announce") || ($cmt eq "Web") || ($cmt eq "CPAN")) {
|
|---|
| 2120 | $src="$src $ENV{'PBTMP'}/pbscript";
|
|---|
| 2121 | } elsif ($cmt eq "Packages") {
|
|---|
| 2122 | # Get package list from file made during build2pkg
|
|---|
| 2123 | open(KEEP,"$ENV{'PBBUILDDIR'}/pbgen-$ENV{'PBPROJVER'}-$ENV{'PBPROJTAG'}-$pbos->{'name'}-$pbos->{'version'}-$pbos->{'arch'}") || die "Unable to read $ENV{'PBBUILDDIR'}/pbgen-$ENV{'PBPROJVER'}-$ENV{'PBPROJTAG'}-$pbos->{'name'}-$pbos->{'version'}-$pbos->{'arch'}";
|
|---|
| 2124 | $src = <KEEP>;
|
|---|
| 2125 | chomp($src);
|
|---|
| 2126 | close(KEEP);
|
|---|
| 2127 | }
|
|---|
| 2128 | if (($cmt eq "Sources") || ($cmt eq "Packages") || ($cmt eq "CPAN")) {
|
|---|
| 2129 | my ($pbpackager) = pb_conf_get("pbpackager");
|
|---|
| 2130 | $ENV{'PBPACKAGER'} = $pbpackager->{$ENV{'PBPROJ'}};
|
|---|
| 2131 | pb_log(0,"Exporting public key for $ENV{'PBPACKAGER'}\n");
|
|---|
| 2132 | # Using pb_system is not working due to redirection below
|
|---|
| 2133 | system("gpg --export -a \'$ENV{'PBPACKAGER'}\' > $ENV{'PBDESTDIR'}/$ENV{'PBPROJ'}.pubkey");
|
|---|
| 2134 | chmod 0644,"$ENV{'PBDESTDIR'}/$ENV{'PBPROJ'}.pubkey";
|
|---|
| 2135 | $src = "$src $ENV{'PBDESTDIR'}/$ENV{'PBPROJ'}.pubkey";
|
|---|
| 2136 | }
|
|---|
| 2137 | # Remove potential leading spaces (cause problem with basename)
|
|---|
| 2138 | $src =~ s/^ *//;
|
|---|
| 2139 | my $basesrc = "";
|
|---|
| 2140 | foreach my $i (split(/ +/,$src)) {
|
|---|
| 2141 | $basesrc .= " ".basename($i);
|
|---|
| 2142 | }
|
|---|
| 2143 |
|
|---|
| 2144 | pb_log(2,"values: ".Dumper(($host,$login,$dir,$port,$tmout,$path,$conf))."\n");
|
|---|
| 2145 | my ($sshhost,$sshdir) = pb_conf_get($host,$dir);
|
|---|
| 2146 | # Not mandatory...
|
|---|
| 2147 | $delivery->{$ENV{'PBPROJ'}} = "" if (not defined $delivery->{$ENV{'PBPROJ'}});
|
|---|
| 2148 | my ($sshlogin,$sshport) = pb_conf_get_if($login,$port);
|
|---|
| 2149 | $sshport->{$ENV{PBPROJ}} = 22 if (not defined $sshport->{$ENV{PBPROJ}});
|
|---|
| 2150 | $sshlogin->{$ENV{PBPROJ}} = getpwuid($UID) if (not defined $sshlogin->{$ENV{PBPROJ}});
|
|---|
| 2151 | my ($vtmout,$vepath);
|
|---|
| 2152 | # ...Except those in virtual context
|
|---|
| 2153 | if ($cmt =~ /^VE/) {
|
|---|
| 2154 | ($vepath) = pb_conf_get($path);
|
|---|
| 2155 | }
|
|---|
| 2156 | if ($cmt =~ /^(V|R)M/) {
|
|---|
| 2157 | $vtmout = pb_distro_get_param($pbos,pb_conf_get_if($tmout));
|
|---|
| 2158 | }
|
|---|
| 2159 | my $remhost = $sshhost->{$ENV{'PBPROJ'}};
|
|---|
| 2160 | my $remdir = $sshdir->{$ENV{'PBPROJ'}};
|
|---|
| 2161 | if ($cmt =~ /^V[EM]|RM/) {
|
|---|
| 2162 | # In that case our real host is in the xxhost with the OS as key, not project as above
|
|---|
| 2163 | $remhost = pb_distro_get_param($pbos,$sshhost);
|
|---|
| 2164 | }
|
|---|
| 2165 | pb_log(2,"ssh: ".Dumper(($remhost,$sshlogin,$remdir,$sshport,$vepath,$rbsconf))."\n");
|
|---|
| 2166 | pb_log(2,"ssh: ".Dumper($vtmout)."\n") if (defined $vtmout);
|
|---|
| 2167 |
|
|---|
| 2168 | my $mac;
|
|---|
| 2169 | if ($cmt !~ /^VE/) {
|
|---|
| 2170 | $mac = "$sshlogin->{$ENV{'PBPROJ'}}\@$remhost";
|
|---|
| 2171 | # Overwrite account value if passed as parameter or forced
|
|---|
| 2172 | $mac = "$ENV{'PBACCOUNT'}\@$remhost" if (defined $ENV{'PBACCOUNT'});
|
|---|
| 2173 | } else {
|
|---|
| 2174 | # VE
|
|---|
| 2175 | $mac = $sshlogin->{$ENV{'PBPROJ'}};
|
|---|
| 2176 | # Overwrite account value if passed as parameter (typically for setup2v)
|
|---|
| 2177 | $mac = $ENV{'PBACCOUNT'} if (defined $ENV{'PBACCOUNT'});
|
|---|
| 2178 | }
|
|---|
| 2179 | pb_log(2, "DEBUG: mac: $mac\n");
|
|---|
| 2180 |
|
|---|
| 2181 | my $tdir;
|
|---|
| 2182 | my $bdir;
|
|---|
| 2183 | if (($cmt eq "Sources") || ($cmt =~ /(V[EM]|RM)Script/)) {
|
|---|
| 2184 | $tdir = "$remdir/$delivery->{$ENV{'PBPROJ'}}/src";
|
|---|
| 2185 | } elsif ($cmt eq "CPAN") {
|
|---|
| 2186 | $tdir = "$remdir";
|
|---|
| 2187 | } elsif ($cmt =~ /(V[EM]|RM)(build|test|prep)/) {
|
|---|
| 2188 | $tdir = $remdir."/$ENV{'PBPROJ'}/pbdelivery";
|
|---|
| 2189 | $bdir = $remdir."/$ENV{'PBPROJ'}/pbbuild";
|
|---|
| 2190 | # Remove a potential $ENV{'HOME'} as bdir should be relative to pb's home
|
|---|
| 2191 | $bdir =~ s|\$ENV.+\}/||;
|
|---|
| 2192 | } elsif ($cmt eq "Announce") {
|
|---|
| 2193 | $tdir = "$remdir/$delivery->{$ENV{'PBPROJ'}}";
|
|---|
| 2194 | } elsif ($cmt eq "Web") {
|
|---|
| 2195 | $tdir = "$remdir/$delivery->{$ENV{'PBPROJ'}}";
|
|---|
| 2196 | } elsif ($cmt eq "Packages") {
|
|---|
| 2197 | if (($pbos->{'type'} eq "rpm") || ($pbos->{'type'} eq "pkg") || ($pbos->{'type'} eq "hpux") || ($pbos->{'type'} eq "tgz")) {
|
|---|
| 2198 | # put packages under an arch subdir
|
|---|
| 2199 | $tdir = "$remdir/$delivery->{$ENV{'PBPROJ'}}/$pbos->{'name'}/$pbos->{'version'}/$pbos->{'arch'}";
|
|---|
| 2200 | } elsif (($pbos->{'type'} eq "deb") || ($pbos->{'type'} eq "ebuild")) {
|
|---|
| 2201 | # No need for an arch subdir
|
|---|
| 2202 | $tdir = "$remdir/$delivery->{$ENV{'PBPROJ'}}/$pbos->{'name'}/$pbos->{'version'}";
|
|---|
| 2203 | } else {
|
|---|
| 2204 | die "Please teach the dev team where to deliver ($pbos->{'type'} type of packages\n";
|
|---|
| 2205 | }
|
|---|
| 2206 |
|
|---|
| 2207 | my $repodir = $tdir;
|
|---|
| 2208 | $repodir =~ s|^$remdir/||;
|
|---|
| 2209 | my $repotag = "";
|
|---|
| 2210 | $repotag = "-$delivery->{$ENV{'PBPROJ'}}" if ($delivery->{$ENV{'PBPROJ'}} ne "");
|
|---|
| 2211 |
|
|---|
| 2212 | my ($pbrepo) = pb_conf_get("pbrepo");
|
|---|
| 2213 |
|
|---|
| 2214 | # Script for Repository management
|
|---|
| 2215 | $pbscript{$v} = "$ENV{'PBBUILDDIR'}/pbscript.$$";
|
|---|
| 2216 |
|
|---|
| 2217 | # That script should be part of the delivery
|
|---|
| 2218 | $src = "$src $pbscript{$v}";
|
|---|
| 2219 | open(PBS,"> $pbscript{$v}") || die "Unable to create $pbscript{$v}";
|
|---|
| 2220 | if ($pbos->{'type'} eq "rpm") {
|
|---|
| 2221 | my $pbsha = pb_distro_get_param($pbos,pb_conf_get("ossha"));
|
|---|
| 2222 | my $gpgcheck = pb_conf_get_if("pbgpgcheck");
|
|---|
| 2223 | my $pbgpgcheck;
|
|---|
| 2224 | $pbgpgcheck = $gpgcheck->{$ENV{PBPROJ}} if (defined $gpgcheck);
|
|---|
| 2225 | # By default force GPG check in repo even if we support signature of packages to fail. This is a best practice
|
|---|
| 2226 | $pbgpgcheck = 1 if (not defined $pbgpgcheck);
|
|---|
| 2227 | # Also make a pbscript to generate dnf/yum/urpmi bases
|
|---|
| 2228 | print PBS << "EOF";
|
|---|
| 2229 | #!/bin/bash
|
|---|
| 2230 | # Prepare a script to ease dnf/yum setup
|
|---|
| 2231 | EOF
|
|---|
| 2232 | print PBS "set -x\n" if ($pbdebug gt 1);
|
|---|
| 2233 | print PBS << "EOF";
|
|---|
| 2234 | cat > $ENV{'PBPROJ'}$repotag.repo << EOT
|
|---|
| 2235 | [$ENV{'PBPROJ'}$repotag]
|
|---|
| 2236 | name=$pbos->{'name'} $pbos->{'version'} $pbos->{'arch'} - $ENV{'PBPROJ'} Vanilla Packages
|
|---|
| 2237 | baseurl=$pbrepo->{$ENV{'PBPROJ'}}/$repodir
|
|---|
| 2238 | enabled=1
|
|---|
| 2239 | gpgcheck=$pbgpgcheck
|
|---|
| 2240 | gpgkey=$pbrepo->{$ENV{'PBPROJ'}}/$repodir/$ENV{'PBPROJ'}.pubkey
|
|---|
| 2241 | EOT
|
|---|
| 2242 | chmod 644 $ENV{'PBPROJ'}$repotag.repo
|
|---|
| 2243 |
|
|---|
| 2244 | # Clean up old repo content
|
|---|
| 2245 | rm -rf headers/ repodata/
|
|---|
| 2246 | # Create yum repo
|
|---|
| 2247 | if [ -x /usr/bin/yum-arch ]; then
|
|---|
| 2248 | yum-arch .
|
|---|
| 2249 | fi
|
|---|
| 2250 | # Create repodata
|
|---|
| 2251 | createrepo -s $pbsha .
|
|---|
| 2252 | # Link to the key
|
|---|
| 2253 | if [ -s $ENV{'PBPROJ'}.pubkey ]; then
|
|---|
| 2254 | # Avoiding creating empty repomd.xml.key; fails on opensuse 12.1
|
|---|
| 2255 | (cd repodata ; ln -sf ../$ENV{'PBPROJ'}.pubkey repomd.xml.key)
|
|---|
| 2256 | fi
|
|---|
| 2257 | # sign the repomd (at least useful for SLES - which requires a local key)
|
|---|
| 2258 | # gpg -a --detach-sign repodata/repomd.xml
|
|---|
| 2259 | # SLES also looks for media.1/info.txt
|
|---|
| 2260 | EOF
|
|---|
| 2261 | if ($pbos->{'family'} eq "md") {
|
|---|
| 2262 | # For Mandriva add urpmi management
|
|---|
| 2263 | print PBS << "EOF";
|
|---|
| 2264 | # Prepare a script to ease urpmi setup
|
|---|
| 2265 | cat > $ENV{'PBPROJ'}$repotag.addmedia << EOT
|
|---|
| 2266 | #rpm --import $pbrepo->{$ENV{'PBPROJ'}}/$repodir/$ENV{'PBPROJ'}.pubkey
|
|---|
| 2267 | urpmi.addmedia $ENV{'PBPROJ'}$repotag $pbrepo->{$ENV{'PBPROJ'}}/$repodir with media_info/hdlist.cz
|
|---|
| 2268 | EOT
|
|---|
| 2269 | chmod 755 $ENV{'PBPROJ'}$repotag.addmedia
|
|---|
| 2270 |
|
|---|
| 2271 | # Clean up old repo content
|
|---|
| 2272 | rm -f hdlist.cz synthesis.hdlist.cz
|
|---|
| 2273 | # Create urpmi repo
|
|---|
| 2274 | genhdlist2 --clean .
|
|---|
| 2275 | if [ \$\? -ne 0 ]; then
|
|---|
| 2276 | genhdlist .
|
|---|
| 2277 | fi
|
|---|
| 2278 | (cd media_info ; ln -sf ../$ENV{'PBPROJ'}.pubkey pubkey)
|
|---|
| 2279 | EOF
|
|---|
| 2280 | }
|
|---|
| 2281 | if ($pbos->{'name'} eq "fedora") {
|
|---|
| 2282 | # Extract the spec file to please Fedora maintainers :-(
|
|---|
| 2283 | print PBS << "EOF";
|
|---|
| 2284 | for p in $basesrc; do
|
|---|
| 2285 | echo \$p | grep -q 'src.rpm'
|
|---|
| 2286 | if [ \$\? -eq 0 ]; then
|
|---|
| 2287 | rpm2cpio \$p | cpio -ivdum --quiet '*.spec'
|
|---|
| 2288 | fi
|
|---|
| 2289 | done
|
|---|
| 2290 | EOF
|
|---|
| 2291 | }
|
|---|
| 2292 | if ($pbos->{'family'} eq "novell") {
|
|---|
| 2293 | # Add ymp scripts for one-click install on SuSE
|
|---|
| 2294 | print PBS << "EOF";
|
|---|
| 2295 | # Prepare a script to ease SuSE one-click install
|
|---|
| 2296 | # Cf: http://de.opensuse.org/1-Klick-Installation/ISV
|
|---|
| 2297 | #
|
|---|
| 2298 | cat > $ENV{'PBPROJ'}$repotag.ymp << EOT
|
|---|
| 2299 | <?xml version="1.0" encoding="utf-8"?>
|
|---|
| 2300 | <!-- vim: set sw=2 ts=2 ai et: -->
|
|---|
| 2301 | <metapackage xmlns:os="http://opensuse.org/Standards/One_Click_Install" xmlns="http://opensuse.org/Standards/One_Click_Install">
|
|---|
| 2302 | <group><!-- The group of software, typically one for project-builder.org -->
|
|---|
| 2303 | <name>$ENV{'PBPROJ'} Bundle</name> <!-- Name of the software group -->
|
|---|
| 2304 | <summary>Software bundle for the $ENV{'PBPROJ'}$repotag project</summary> <!--This message is shown to the user and should describe the whole bundle -->
|
|---|
| 2305 | <description>This is the summary of the $ENV{'PBPROJ'}$repotag Project
|
|---|
| 2306 |
|
|---|
| 2307 | Details are available on a per package basis below
|
|---|
| 2308 |
|
|---|
| 2309 | </description><!--This is also shown to the user -->
|
|---|
| 2310 | <remainSubscribed>false</remainSubscribed> <!-- Don't know what it mean -->
|
|---|
| 2311 | <repositories><!-- List of needed repositories -->
|
|---|
| 2312 | <repository>
|
|---|
| 2313 | <name>$ENV{'PBPROJ'}$repotag Repository</name> <!-- Name of the repository -->
|
|---|
| 2314 | <summary>This repository contains the $ENV{'PBPROJ'}$repotag project packages.</summary> <!-- Summary of the repository -->
|
|---|
| 2315 | <description>This repository contains the $ENV{'PBPROJ'}$repotag project packages.</description><!-- This description is shown to the user -->
|
|---|
| 2316 | <url>$pbrepo->{$ENV{'PBPROJ'}}/$repodir</url><!--URL of repository, which is added -->
|
|---|
| 2317 | </repository>
|
|---|
| 2318 | </repositories>
|
|---|
| 2319 | <software><!-- A List of packages, which should be added through the one-click-installation -->
|
|---|
| 2320 | EOT
|
|---|
| 2321 | for p in $basesrc; do
|
|---|
| 2322 | sum=`rpm -q --qf '%{SUMMARY}' \$p`
|
|---|
| 2323 | name=`rpm -q --qf '%{NAME}' \$p`
|
|---|
| 2324 | desc=`rpm -q --qf '%{description}' \$p`
|
|---|
| 2325 | cat >> $ENV{'PBPROJ'}$repotag.ymp << EOT
|
|---|
| 2326 | <item>
|
|---|
| 2327 | <name>\$name</name><!-- Name of the package, is shown to the user and used to identify the package at the repository -->
|
|---|
| 2328 | <summary>\$sum</summary> <!-- Summary of the package -->
|
|---|
| 2329 | <description>\$desc</description> <!-- Description, is shown to the user -->
|
|---|
| 2330 | </item>
|
|---|
| 2331 | EOT
|
|---|
| 2332 | done
|
|---|
| 2333 | cat >> $ENV{'PBPROJ'}$repotag.ymp << EOT
|
|---|
| 2334 | </software>
|
|---|
| 2335 | </group>
|
|---|
| 2336 | </metapackage>
|
|---|
| 2337 | EOT
|
|---|
| 2338 | chmod 644 $ENV{'PBPROJ'}$repotag.ymp
|
|---|
| 2339 | EOF
|
|---|
| 2340 | }
|
|---|
| 2341 | } elsif ($pbos->{'type'} eq "deb") {
|
|---|
| 2342 | # Also make a pbscript to generate apt bases
|
|---|
| 2343 | # Cf: http://www.debian.org/doc/manuals/repository-howto/repository-howto.fr.html
|
|---|
| 2344 | # This dirname removes ver
|
|---|
| 2345 | my $debarch = $pbos->{'arch'};
|
|---|
| 2346 | $debarch = "amd64" if ($pbos->{'arch'} eq "x86_64");
|
|---|
| 2347 | my $rpd = dirname("$pbrepo->{$ENV{'PBPROJ'}}/$repodir");
|
|---|
| 2348 | # Remove extra . in path to fix #522
|
|---|
| 2349 | $rpd =~ s|/./|/|g;
|
|---|
| 2350 | my ($projcomponent_map) = pb_conf_get_if("projcomponent");
|
|---|
| 2351 | pb_log(2,"projcomponent = ".Dumper($projcomponent_map)."\n");
|
|---|
| 2352 | my $projcomponent = $projcomponent_map->{$ENV{PBPROJ}};
|
|---|
| 2353 | $projcomponent ||= 'contrib';
|
|---|
| 2354 | print PBS << "EOF";
|
|---|
| 2355 | #!/bin/bash
|
|---|
| 2356 | # Prepare a script to ease apt setup
|
|---|
| 2357 | cat > $ENV{'PBPROJ'}$repotag.sources.list << EOT
|
|---|
| 2358 | deb $rpd $pbos->{'version'} $projcomponent
|
|---|
| 2359 | deb-src $rpd $pbos->{'version'} $projcomponent
|
|---|
| 2360 | EOT
|
|---|
| 2361 | chmod 644 $ENV{'PBPROJ'}$repotag.sources.list
|
|---|
| 2362 |
|
|---|
| 2363 | # Up two levels to deal with the dist dir cross versions
|
|---|
| 2364 | cd ..
|
|---|
| 2365 | mkdir -p dists/$pbos->{'version'}/$projcomponent/binary-$debarch dists/$pbos->{'version'}/$projcomponent/source
|
|---|
| 2366 |
|
|---|
| 2367 | # Prepare a script to create apt info file
|
|---|
| 2368 | # Reuse twice after
|
|---|
| 2369 | TMPD=`mktemp -d /tmp/pb.XXXXXXXXXX` || exit 1
|
|---|
| 2370 | mkdir -p \$TMPD
|
|---|
| 2371 | cat > \$TMPD/Release << EOT
|
|---|
| 2372 | Archive: unstable
|
|---|
| 2373 | Component: $projcomponent
|
|---|
| 2374 | Origin: $ENV{'PBPROJ'}$repotag
|
|---|
| 2375 | Label: $ENV{'PBPROJ'}$repotag dev repository $pbrepo->{$ENV{'PBPROJ'}}
|
|---|
| 2376 | EOT
|
|---|
| 2377 |
|
|---|
| 2378 | echo "Creating Packages metadata"
|
|---|
| 2379 | for i in dists/$pbos->{version}/$projcomponent/binary-*; do
|
|---|
| 2380 | arch=`basename \$i | sed 's/binary-//'`
|
|---|
| 2381 | echo "Packages for \$arch:"
|
|---|
| 2382 | dpkg-scanpackages -a\$arch $pbos->{'version'} /dev/null > dists/$pbos->{'version'}/$projcomponent/binary-\$arch/Packages
|
|---|
| 2383 | gzip -9 < dists/$pbos->{'version'}/$projcomponent/binary-\$arch/Packages > dists/$pbos->{'version'}/$projcomponent/binary-\$arch/Packages.gz
|
|---|
| 2384 | bzip2 -9 < dists/$pbos->{'version'}/$projcomponent/binary-\$arch/Packages > dists/$pbos->{'version'}/$projcomponent/binary-\$arch/Packages.bz2
|
|---|
| 2385 | done
|
|---|
| 2386 | echo "Creating Contents metadata"
|
|---|
| 2387 | apt-ftparchive contents $pbos->{'version'} | gzip -c9 > dists/$pbos->{'version'}/Contents.gz
|
|---|
| 2388 | echo "Creating Release metadata ($pbos->{'arch'} aka $debarch)"
|
|---|
| 2389 | cat \$TMPD/Release > dists/$pbos->{'version'}/$projcomponent/binary-$debarch/Release
|
|---|
| 2390 | echo "Architecture: $debarch" >> dists/$pbos->{'version'}/$projcomponent/binary-$debarch/Release
|
|---|
| 2391 | echo "Creating Source metadata"
|
|---|
| 2392 | dpkg-scansources $pbos->{'version'} /dev/null > dists/$pbos->{'version'}/$projcomponent/source/Sources
|
|---|
| 2393 | gzip -9 < dists/$pbos->{'version'}/$projcomponent/source/Sources > dists/$pbos->{'version'}/$projcomponent/source/Sources.gz
|
|---|
| 2394 | bzip2 -9 < dists/$pbos->{'version'}/$projcomponent/source/Sources > dists/$pbos->{'version'}/$projcomponent/source/Sources.bz2
|
|---|
| 2395 | cat \$TMPD/Release > dists/$pbos->{'version'}/$projcomponent/source/Release
|
|---|
| 2396 | echo "Architecture: Source" >> dists/$pbos->{'version'}/$projcomponent/source/Release
|
|---|
| 2397 | echo "Creating Release metadata"
|
|---|
| 2398 | # Signing that file would be useful but uneasy as gpg keys are not there
|
|---|
| 2399 | # Cf: http://wiki.debian.org/SecureApt
|
|---|
| 2400 | # Same as for repomd
|
|---|
| 2401 | apt-ftparchive -o APT::FTPArchive::Release::Suite=$pbos->{version} release dists/$pbos->{'version'} > dists/$pbos->{'version'}/Release
|
|---|
| 2402 | rm -rf \$TMPD
|
|---|
| 2403 | EOF
|
|---|
| 2404 | } elsif ($pbos->{'type'} eq "ebuild") {
|
|---|
| 2405 | # make a pbscript to generate links to latest version
|
|---|
| 2406 | print PBS << "EOF";
|
|---|
| 2407 | #!/bin/bash
|
|---|
| 2408 | # Prepare a script to create correct links
|
|---|
| 2409 | for p in $src; do
|
|---|
| 2410 | echo \$p | grep -q '.ebuild'
|
|---|
| 2411 | if [ \$\? -eq 0 ]; then
|
|---|
| 2412 | pp=`echo \$j | sed 's/-[0-9.]+-r[0-9]*//'`
|
|---|
| 2413 | ln -sf \$j \$pp
|
|---|
| 2414 | fi
|
|---|
| 2415 | done
|
|---|
| 2416 | EOF
|
|---|
| 2417 | }
|
|---|
| 2418 | close(PBS);
|
|---|
| 2419 | chmod 0755,$pbscript{$v};
|
|---|
| 2420 | } else {
|
|---|
| 2421 | return;
|
|---|
| 2422 | }
|
|---|
| 2423 |
|
|---|
| 2424 | # Useless for VE
|
|---|
| 2425 | my $nport = pb_get_port($sshport,$pbos,$cmt) if ($cmt !~ /^VE/);
|
|---|
| 2426 |
|
|---|
| 2427 | # Remove a potential $ENV{'HOME'} as tdir should be relative to pb's home
|
|---|
| 2428 | if ($cmt =~ /^VE/o) {
|
|---|
| 2429 | $tdir =~ s|\$ENV.+\}/|| or confess "for $cmt: $tdir must have \$ENV{'HOME'} in it or the remainder of the code won't work since some parts use relative pathing and others will try absolute. Use a symlink if necessary to place the real files in a different place than under your home directory";
|
|---|
| 2430 | } else {
|
|---|
| 2431 | # process, ok if not present.
|
|---|
| 2432 | $tdir =~ s|\$ENV.+\}/||;
|
|---|
| 2433 | }
|
|---|
| 2434 |
|
|---|
| 2435 | my $tm = "";
|
|---|
| 2436 | if ($cmt =~ /^(V|R)M/) {
|
|---|
| 2437 | $tm = "sleep $vtmout" if (defined $vtmout);
|
|---|
| 2438 | }
|
|---|
| 2439 |
|
|---|
| 2440 | # ssh communication if not VE or CPAN
|
|---|
| 2441 | # should use a hash instead...
|
|---|
| 2442 | my ($shcmd,$shcmdroot,$cpcmd,$cptarget,$cp2target);
|
|---|
| 2443 | my $tpdir;
|
|---|
| 2444 | my $tp;
|
|---|
| 2445 | my $context = "$ENV{'PBTMP'}";
|
|---|
| 2446 | my %tag;
|
|---|
| 2447 | my $dkaccount = "";
|
|---|
| 2448 | my $cmd1 = "";
|
|---|
| 2449 | my $homedir = "";
|
|---|
| 2450 | if ($cmt =~ /^VE/) {
|
|---|
| 2451 | $tp = pb_path_expand($vepath->{$ENV{'PBPROJ'}});
|
|---|
| 2452 | $vetype = pb_ve_get_type($vetype);
|
|---|
| 2453 | if ($vetype eq "docker") {
|
|---|
| 2454 | $tpdir = "/";
|
|---|
| 2455 | } else {
|
|---|
| 2456 | $tpdir = pb_path_expand("$tp/$pbos->{'name'}/$pbos->{'version'}/$pbos->{'arch'}");
|
|---|
| 2457 | }
|
|---|
| 2458 | my $arch = pb_get_arch();
|
|---|
| 2459 | if ($vetype eq "chroot") {
|
|---|
| 2460 | $shcmdroot = "sudo /usr/sbin/chroot $tpdir ";
|
|---|
| 2461 | $shcmd = "$shcmdroot /bin/su - $mac -c ";
|
|---|
| 2462 | } elsif ($vetype eq "schroot") {
|
|---|
| 2463 | $shcmd = "schroot $tp -u $mac -- ";
|
|---|
| 2464 | } elsif ($vetype eq "docker") {
|
|---|
| 2465 | # docker manages the storage so rely on it
|
|---|
| 2466 | $shcmdroot = "";
|
|---|
| 2467 | my $docrepo = pb_ve_docker_repo();
|
|---|
| 2468 | $cmd1 = pb_check_req("docker",0);
|
|---|
| 2469 | #my ($dockeropt) = pb_conf_get_if("dockeropt");
|
|---|
| 2470 | # pbimage is used for docker and is setup to the right name depending on the step:
|
|---|
| 2471 | # TODO: This is not coded yet
|
|---|
| 2472 | my $pbimage = undef;
|
|---|
| 2473 | # step 0 : nothing at creation -> tag n-v-a (made in VE.pm)
|
|---|
| 2474 | # step 1 : n-v-a + setup -> tag n-v-a-pb
|
|---|
| 2475 | # step 2 : n-v-a-pb + build -> tag n-v-a-pb-pbproj
|
|---|
| 2476 | # step 3 : n-v-a-pb-pbproj at use
|
|---|
| 2477 | if ((not defined $pbimage) || ($pbimage eq "")) {
|
|---|
| 2478 | # If no image name given, create a naming convention
|
|---|
| 2479 | $tag{1} = "$docrepo$pbos->{'name'}-$pbos->{'version'}-$pbos->{'arch'}";
|
|---|
| 2480 | $tag{2} = "$tag{1}-pb";
|
|---|
| 2481 | $tag{3} = "$tag{2}-$ENV{'PBPROJ'}";
|
|---|
| 2482 | } else {
|
|---|
| 2483 | # If we were given an image name, just use it
|
|---|
| 2484 | $tag{1} = $pbimage;
|
|---|
| 2485 | $tag{2} = $pbimage;
|
|---|
| 2486 | $tag{3} = $pbimage;
|
|---|
| 2487 | }
|
|---|
| 2488 | # If we do not create the image, then use the one we should have
|
|---|
| 2489 | my $found = pb_ve_docker_get_image($tag{$pbstep});
|
|---|
| 2490 | # Now we use that image to do what is needed
|
|---|
| 2491 | # use a dockerfile to ease the creation of next images
|
|---|
| 2492 | # the context is in an empty temp dir
|
|---|
| 2493 | my $tmpd = "$context/Dockerfile";
|
|---|
| 2494 | open(DOCKER, "> $tmpd") || die "Unable to create the docker file $tmpd";
|
|---|
| 2495 | print DOCKER "FROM $tag{$pbstep}\n";
|
|---|
| 2496 | print DOCKER "MAINTAINER project-builder.org aka pb\n";
|
|---|
| 2497 | if ($pbstep == 1) {
|
|---|
| 2498 | # setup done as root
|
|---|
| 2499 | $dkaccount = "root";
|
|---|
| 2500 | } else {
|
|---|
| 2501 | # Rest done as pb
|
|---|
| 2502 | $dkaccount = "pb";
|
|---|
| 2503 | }
|
|---|
| 2504 | print DOCKER "USER $dkaccount\n";
|
|---|
| 2505 | if ($pbstep <= 2) {
|
|---|
| 2506 | $shcmd = "$cmd1 build -t $tag{$pbstep+1} $context";
|
|---|
| 2507 | } else {
|
|---|
| 2508 | # As we are in run phase use docker run. cmd will be completed below
|
|---|
| 2509 | $shcmd = "$cmd1 run --cidfile=\"$ENV{'PBTMP'}/ctn.cid\" --user $dkaccount --name $pbos->{'name'}-$pbos->{'version'}-$pbos->{'arch'}-$cmt";
|
|---|
| 2510 | }
|
|---|
| 2511 | #$shcmd = "$cmd1 build $dockeropt->{$ENV{'PBPROJ'}} -t $tag{$pbstep+1} $context";
|
|---|
| 2512 | }
|
|---|
| 2513 | $shcmd = "setarch i386 $shcmd" if (($pbos->{'arch'} =~ /i[3456]86/) && ($arch eq 'x86_64'));
|
|---|
| 2514 | if (($cmt =~ /VE/) && ($vetype ne "docker")) {
|
|---|
| 2515 | # We need to get the home dir of the target account to deliver in the right place
|
|---|
| 2516 | open(PASS,"$tpdir/etc/passwd") || die "Unable to open $tpdir/etc/passwd: $!";
|
|---|
| 2517 | while (<PASS>) {
|
|---|
| 2518 | my ($c1,$c2,$c3,$c4,$c5,$c6,$c7) = split(/:/);
|
|---|
| 2519 | $homedir = $c6 if ($c1 =~ /^$mac$/);
|
|---|
| 2520 | pb_log(3,"Homedir: $homedir - account: $c6\n");
|
|---|
| 2521 | }
|
|---|
| 2522 | close(PASS);
|
|---|
| 2523 | $cpcmd = "sudo /bin/cp -r ";
|
|---|
| 2524 | }
|
|---|
| 2525 | if (($cmt =~ /VE/) && ($vetype eq "docker")) {
|
|---|
| 2526 | if ($pbstep >= 2) {
|
|---|
| 2527 | # We need to get the home dir of the target account to deliver in the right place
|
|---|
| 2528 | $homedir = `$cmd1 run --cidfile="$ENV{'PBTMP'}/ctn.cid" $tag{$pbstep} grep -E '^$dkaccount:' /etc/passwd | cut -d: -f6`;
|
|---|
| 2529 | chomp($homedir);
|
|---|
| 2530 | open(CID,"$ENV{'PBTMP'}/ctn.cid") || confess "Unable to open $ENV{'PBTMP'}/ctn.cid";
|
|---|
| 2531 | my $cid = <CID>;
|
|---|
| 2532 | close(CID);
|
|---|
| 2533 | pb_system("$cmd1 rm $cid","","quiet");
|
|---|
| 2534 | unlink("$ENV{'PBTMP'}/ctn.cid");
|
|---|
| 2535 | } else {
|
|---|
| 2536 | $homedir = "/";
|
|---|
| 2537 | }
|
|---|
| 2538 | $cpcmd = "cp -r ";
|
|---|
| 2539 | }
|
|---|
| 2540 | $cptarget = "$tpdir/$homedir/$tdir";
|
|---|
| 2541 | if ($cmt =~ /VE(build|prep)/) {
|
|---|
| 2542 | $cp2target = "$tpdir/$homedir/$bdir";
|
|---|
| 2543 | }
|
|---|
| 2544 | pb_log(2,"On VE using $cptarget as target dir to copy to\n");
|
|---|
| 2545 | } elsif ($cmt eq "CPAN") {
|
|---|
| 2546 | my $ftpput = pb_check_req("ncftpput",1);
|
|---|
| 2547 | my $ftpget = pb_check_req("wget",1);
|
|---|
| 2548 | my ($cpanuser,$cpanpasswd) = pb_conf_get_if("cpanuser","cpanpasswd");
|
|---|
| 2549 | return if ((not defined $cpanuser) || (not defined $cpanuser->{$ENV{'PBPROJ'}}));
|
|---|
| 2550 | return if ((not defined $cpanpasswd) || (not defined $cpanpasswd->{$ENV{'PBPROJ'}}));
|
|---|
| 2551 | my ($cpansubdir) = pb_conf_get_if("cpansubdir");
|
|---|
| 2552 | $shcmd = "$ftpget --post-data \'HIDDENNAME=".$cpanuser->{$ENV{'PBPROJ'}};
|
|---|
| 2553 | $shcmd .= "&user=".$cpanuser->{$ENV{'PBPROJ'}};
|
|---|
| 2554 | $shcmd .= "&password=".$cpanpasswd->{$ENV{'PBPROJ'}};
|
|---|
| 2555 | $shcmd .= "&SUBMIT_pause99_add_uri_upload=\"Upload the checked files\"";
|
|---|
| 2556 | $shcmd .= "&pause99_add_uri_subdirtext=".$cpansubdir->{$ENV{'PBPROJ'}} if ((defined $cpansubdir) && (defined $cpansubdir->{$ENV{'PBPROJ'}}));
|
|---|
| 2557 | foreach my $s (split(/ /,$src)) {
|
|---|
| 2558 | $shcmd .= "&pause99_add_uri_upload=".basename($s);
|
|---|
| 2559 | }
|
|---|
| 2560 | $shcmd .= "'";
|
|---|
| 2561 | $cpcmd = "$ftpput $host $dir";
|
|---|
| 2562 | $cptarget = "CPAN";
|
|---|
| 2563 | } else {
|
|---|
| 2564 | my $keyopt = "";
|
|---|
| 2565 | if ($cmt !~ /Packages/) {
|
|---|
| 2566 | my $keyfile = pb_ssh_get(0,$remhost,$nport);
|
|---|
| 2567 | $keyopt = "-i $keyfile" if (defined $keyfile);
|
|---|
| 2568 | }
|
|---|
| 2569 | my $sshcmd = pb_check_req("ssh",1);
|
|---|
| 2570 | my $scpcmd = pb_check_req("scp",1);
|
|---|
| 2571 | $shcmd = "$sshcmd $keyopt -q -o NoHostAuthenticationForLocalhost=yes -p $nport $mac";
|
|---|
| 2572 | $cpcmd = "$scpcmd $keyopt -p -o NoHostAuthenticationForLocalhost=yes -P $nport";
|
|---|
| 2573 | $cptarget = "$mac:$tdir";
|
|---|
| 2574 | if ($cmt =~ /^(V|R)M(build|prep)/) {
|
|---|
| 2575 | $cp2target = "$mac:$bdir";
|
|---|
| 2576 | }
|
|---|
| 2577 | }
|
|---|
| 2578 |
|
|---|
| 2579 | my $logres = "";
|
|---|
| 2580 | # Do not touch when just announcing
|
|---|
| 2581 | if (($cmt ne "Announce") && ($cmt ne "CPAN")) {
|
|---|
| 2582 | # For docker everything is done in the Dockerfile for steps < 3
|
|---|
| 2583 | if (($cmt =~ /^VE/) && ($vetype eq "docker") && ($pbstep < 3)) {
|
|---|
| 2584 | print DOCKER "RUN mkdir -p $cptarget\n";
|
|---|
| 2585 | print DOCKER "RUN cd $cptarget ; for i in $basesrc; do if [ -f \$i ]; then rm -f \$i; fi; done\n";
|
|---|
| 2586 | } elsif (($cmt =~ /^VE/) && ($vetype eq "docker") && ($pbstep >= 3)) {
|
|---|
| 2587 | # Nothing to do here
|
|---|
| 2588 | } else {
|
|---|
| 2589 | pb_system("$shcmd \"rm -rf $tdir ; mkdir -p $tdir ; $cmd\' | bash -e\"","Preparing $tdir on $cptarget");
|
|---|
| 2590 | }
|
|---|
| 2591 | } else {
|
|---|
| 2592 | $logres = "> ";
|
|---|
| 2593 | }
|
|---|
| 2594 |
|
|---|
| 2595 | if ($cmt =~ /SandBox/) {
|
|---|
| 2596 | # Install from sandbox mean using the result of the just passed sbx2build command
|
|---|
| 2597 | # Get content saved in cms2build
|
|---|
| 2598 | my ($pkg) = pb_conf_read("$ENV{'PBDESTDIR'}/$ENV{'PBPROJVER'}-$ENV{'PBPROJTAG'}.pb","pbpkg");
|
|---|
| 2599 | my $pbextdir = pb_get_extdir();
|
|---|
| 2600 | confess "Unable to get package list" if (not defined $pkg);
|
|---|
| 2601 |
|
|---|
| 2602 | # We consider 2 specific packages
|
|---|
| 2603 | my $vertag1 = $pkg->{"ProjectBuilder"};
|
|---|
| 2604 | my $vertag2 = $pkg->{"project-builder"};
|
|---|
| 2605 | # get the version of the current package - maybe different
|
|---|
| 2606 | pb_log(2,"Vertag1: $vertag1\n");
|
|---|
| 2607 | pb_log(2,"Vertag2: $vertag2\n");
|
|---|
| 2608 | my ($pbver1,$tmp1) = split(/-/,$vertag1);
|
|---|
| 2609 | my ($pbver2,$tmp2) = split(/-/,$vertag2);
|
|---|
| 2610 | if ($cmt =~ /VE/) {
|
|---|
| 2611 | # Copy inside the VE
|
|---|
| 2612 | if ($vetype ne "docker") {
|
|---|
| 2613 | copy("$ENV{'PBDESTDIR'}/ProjectBuilder-$pbver1$pbextdir.tar.gz","$tpdir/tmp");
|
|---|
| 2614 | copy("$ENV{'PBDESTDIR'}/project-builder-$pbver2$pbextdir.tar.gz","$tpdir/tmp");
|
|---|
| 2615 | } else {
|
|---|
| 2616 | copy("$ENV{'PBDESTDIR'}/ProjectBuilder-$pbver1$pbextdir.tar.gz","$context");
|
|---|
| 2617 | copy("$ENV{'PBDESTDIR'}/project-builder-$pbver2$pbextdir.tar.gz","$context");
|
|---|
| 2618 | print DOCKER "COPY ProjectBuilder-$pbver1$pbextdir.tar.gz /tmp/\n";
|
|---|
| 2619 | print DOCKER "COPY project-builder-$pbver2$pbextdir.tar.gz /tmp/\n";
|
|---|
| 2620 | }
|
|---|
| 2621 | } else {
|
|---|
| 2622 | pb_system("$cpcmd $ENV{'PBDESTDIR'}/ProjectBuilder-$pbver1$pbextdir.tar.gz $ENV{'PBDESTDIR'}/project-builder-$pbver2$pbextdir.tar.gz $mac:/tmp","Copying local project files to VM/RM");
|
|---|
| 2623 | }
|
|---|
| 2624 | }
|
|---|
| 2625 |
|
|---|
| 2626 | pb_log(0,"Sources handled ($cmt): $src\n");
|
|---|
| 2627 | # For docker everything is done in the Dockerfile
|
|---|
| 2628 | if (($cmt =~ /^VE/) && ($vetype eq "docker") && ($pbstep < 3)) {
|
|---|
| 2629 | foreach my $f (split(/ +/,$src)) {
|
|---|
| 2630 | copy("$f","$context");
|
|---|
| 2631 | print DOCKER "COPY ".basename($f)." $cptarget/\n";
|
|---|
| 2632 | }
|
|---|
| 2633 | print DOCKER "RUN cd $cptarget ; $cmd\n" if ((defined $cmd) && ($cmd ne ""));
|
|---|
| 2634 | } elsif (($cmt =~ /^VE/) && ($vetype eq "docker") && ($pbstep >= 3)) {
|
|---|
| 2635 | # Nothing to do
|
|---|
| 2636 | } else {
|
|---|
| 2637 | pb_system("cd $ENV{'PBBUILDDIR'} ; $cpcmd $src $cptarget 2> /dev/null","$cmt delivery in $cptarget");
|
|---|
| 2638 | }
|
|---|
| 2639 |
|
|---|
| 2640 | # For VE we need to change the owner manually
|
|---|
| 2641 | if ($cmt =~ /^VE/) {
|
|---|
| 2642 | if ($vetype ne "docker") {
|
|---|
| 2643 | my $sudomode = pb_distro_get_param($pbos,pb_conf_get("ossudoersmode"));
|
|---|
| 2644 | my $res = pb_system("$shcmdroot sed -i '/requiretty/d' /etc/sudoers","Removing potential requiretty in sudoers","quiet");
|
|---|
| 2645 | 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"));
|
|---|
| 2646 | pb_system("$shcmd \"sudo chown -R $mac $tdir\"","Adapt owner in $tdir to $mac");
|
|---|
| 2647 | } else {
|
|---|
| 2648 | print DOCKER "RUN sed -i '/requiretty/d' /etc/sudoers\n" if ($pbstep == 1);
|
|---|
| 2649 | }
|
|---|
| 2650 | }
|
|---|
| 2651 |
|
|---|
| 2652 | # Use the right script name depending on context
|
|---|
| 2653 | my $pbscript2;
|
|---|
| 2654 | if (($cmt =~ /^(V[EM]|RM)/) || ($cmt =~ /Packages/)){
|
|---|
| 2655 | $pbscript2 = $pbscript{$v};
|
|---|
| 2656 | } else {
|
|---|
| 2657 | $pbscript2 = "pbscript";
|
|---|
| 2658 | }
|
|---|
| 2659 |
|
|---|
| 2660 | # It's already ready for CPAN
|
|---|
| 2661 | my $shcmdbase = $shcmd;
|
|---|
| 2662 | my $dkcmd;
|
|---|
| 2663 | if ($cmt ne "CPAN") {
|
|---|
| 2664 | if (($cmt =~ /^VE/) && ($vetype eq "docker") && ($pbstep < 3)) {
|
|---|
| 2665 | copy("$pbscript2","$context");
|
|---|
| 2666 | my $s = basename($pbscript2);
|
|---|
| 2667 | print DOCKER "COPY $s $cptarget/\n";
|
|---|
| 2668 | # call directly with perl to avoid text file busy error messages
|
|---|
| 2669 | print DOCKER "RUN cd $cptarget ; perl ./$s ; if [ '$pbkeep' = '0' ]; then rm -f $s; fi\n";
|
|---|
| 2670 | print DOCKER "RUN rm -rf $cptarget/*\n";
|
|---|
| 2671 | print DOCKER "RUN chown -R $dkaccount $cptarget\n" if ($pbstep == 1);
|
|---|
| 2672 | close(DOCKER);
|
|---|
| 2673 | } elsif (($cmt =~ /^VE/) && ($vetype eq "docker") && ($pbstep >= 3)) {
|
|---|
| 2674 | $dkcmd = "/bin/bash $homedir/$tdir-2/".basename($pbscript2);
|
|---|
| 2675 | } else {
|
|---|
| 2676 | my $s = basename($pbscript2);
|
|---|
| 2677 | $shcmd .= " \"echo \'cd $tdir ; if [ -x $s ]; then ./$s; fi ; if [ $pbkeep == 0 ]; then rm -f $s; fi\' | bash\"";
|
|---|
| 2678 | }
|
|---|
| 2679 | }
|
|---|
| 2680 | my $cmdverb = "verbose";
|
|---|
| 2681 | if (($cmt eq "Announce") || ($cmt eq "CPAN")) {
|
|---|
| 2682 | $cmdverb = undef;
|
|---|
| 2683 | } elsif (defined ($v)) {
|
|---|
| 2684 | $cmdverb = "verbose_\[$v\] ";
|
|---|
| 2685 | }
|
|---|
| 2686 | # this is where we lanch the execution
|
|---|
| 2687 | if (($cmt =~ /^VE/) && ($vetype eq "docker") && ($pbstep >= 3)) {
|
|---|
| 2688 | pb_mkdir_p("$ENV{'PBTMP'}/vebuild");
|
|---|
| 2689 | my $tsrc = "";
|
|---|
| 2690 | foreach my $f (split(/ +/,$src)) {
|
|---|
| 2691 | copy("$f","$ENV{'PBTMP'}/vebuild");
|
|---|
| 2692 | $tsrc .= " ".basename($f);
|
|---|
| 2693 | }
|
|---|
| 2694 | my $ts = "$ENV{'PBTMP'}/vebuild/".basename($pbscript2);
|
|---|
| 2695 | open(DOCKER," > $ts") || confess "Unable to create $ts";
|
|---|
| 2696 | print DOCKER "#!/bin/bash\n";
|
|---|
| 2697 | print DOCKER "# Put content from host to guest, copying to have the correct uid/gid and rights to do so\n";
|
|---|
| 2698 | print DOCKER "# set -x\n";
|
|---|
| 2699 | print DOCKER "for i in $tsrc; do\n";
|
|---|
| 2700 | print DOCKER " # Cleanup first to avoid rights issues for root owned files e.g.\n";
|
|---|
| 2701 | print DOCKER " rm -f $homedir/$tdir/\$i\n";
|
|---|
| 2702 | print DOCKER " cp $homedir/$tdir-2/\$i $homedir/$tdir\n";
|
|---|
| 2703 | print DOCKER "done\n";
|
|---|
| 2704 | print DOCKER "(cd $homedir/$tdir-2 ; ls -al)\n";
|
|---|
| 2705 | print DOCKER pb_get_content($pbscript2);
|
|---|
| 2706 | print DOCKER "\n# Get content back from guest in a host dir\n";
|
|---|
| 2707 | # Host dir seen as TDIR in container
|
|---|
| 2708 | $cp2target = "$ENV{'PBBUILDDIR'}/$ENV{'PBPROJVER'}-$ENV{'PBPROJTAG'}-$pbos->{'name'}-$pbos->{'version'}-$pbos->{'arch'}";
|
|---|
| 2709 | pb_mkdir_p("$cp2target");
|
|---|
| 2710 | chmod 0777,"$cp2target";
|
|---|
| 2711 | print DOCKER "TDIR=$homedir/$bdir-2/$ENV{'PBPROJVER'}-$ENV{'PBPROJTAG'}-$pbos->{'name'}-$pbos->{'version'}-$pbos->{'arch'}\n";
|
|---|
| 2712 | print DOCKER "for i in $homedir/$bdir/*; do\n";
|
|---|
| 2713 | print DOCKER " # Cleanup first to avoid rights issues for root owned files e.g.\n";
|
|---|
| 2714 | print DOCKER " j=\`basename \$i\`\n";
|
|---|
| 2715 | print DOCKER " rm -f \$TDIR/\$j\n";
|
|---|
| 2716 | print DOCKER " cp -r \$i \$TDIR\n";
|
|---|
| 2717 | print DOCKER "done\n";
|
|---|
| 2718 | print DOCKER "find \$TDIR -type f -print0 | xargs -0 chmod 644\n";
|
|---|
| 2719 | print DOCKER "find \$TDIR -type d -print0 | xargs -0 chmod 777 2> /dev/null\n";
|
|---|
| 2720 | #print DOCKER "ls -al \$TDIR\n";
|
|---|
| 2721 | close(DOCKER);
|
|---|
| 2722 | $shcmd .= " -v $ENV{'PBBUILDDIR'}:$homedir/$bdir-2 -v $ENV{'PBTMP'}/vebuild:$homedir/$tdir-2 -w $homedir/$tdir-2 $tag{$pbstep} $dkcmd";
|
|---|
| 2723 | }
|
|---|
| 2724 | my $ret = pb_system("$shcmd","Executing pbscript on $cptarget if needed",$cmdverb);
|
|---|
| 2725 |
|
|---|
| 2726 | if ($cmt =~ /^(V[EM]|RM)build/) {
|
|---|
| 2727 | # Get back info on pkg produced, compute their name and get them from the VM/RM
|
|---|
| 2728 | pb_system("$cpcmd $cp2target/pbgen-$ENV{'PBPROJVER'}-$ENV{'PBPROJTAG'}-$pbos->{'name'}-$pbos->{'version'}-$pbos->{'arch'} $ENV{'PBBUILDDIR'}/pbgen-$ENV{'PBPROJVER'}-$ENV{'PBPROJTAG'}.$$ 2> /dev/null","Get package names in $cp2target");
|
|---|
| 2729 | if (not -f "$ENV{'PBBUILDDIR'}/pbgen-$ENV{'PBPROJVER'}-$ENV{'PBPROJTAG'}.$$") {
|
|---|
| 2730 | pb_log(0,"ERROR with VM/RM $v on getting $ENV{'PBBUILDDIR'}/pbgen-$ENV{'PBPROJVER'}-$ENV{'PBPROJTAG'}.$$\n");
|
|---|
| 2731 | } else {
|
|---|
| 2732 | open(KEEP,"$ENV{'PBBUILDDIR'}/pbgen-$ENV{'PBPROJVER'}-$ENV{'PBPROJTAG'}.$$") || die "Unable to read $ENV{'PBBUILDDIR'}/pbgen-$ENV{'PBPROJVER'}-$ENV{'PBPROJTAG'}.$$";
|
|---|
| 2733 | my $src = <KEEP>;
|
|---|
| 2734 | chomp($src);
|
|---|
| 2735 | close(KEEP);
|
|---|
| 2736 | unlink("$ENV{'PBBUILDDIR'}/pbgen-$ENV{'PBPROJVER'}-$ENV{'PBPROJTAG'}.$$");
|
|---|
| 2737 |
|
|---|
| 2738 | $src =~ s/^ *//;
|
|---|
| 2739 | pb_mkdir_p("$ENV{'PBBUILDDIR'}/$pbos->{'name'}/$pbos->{'version'}/$pbos->{'arch'}");
|
|---|
| 2740 | # Change pgben to make the next send2target happy
|
|---|
| 2741 | my $made = "";
|
|---|
| 2742 |
|
|---|
| 2743 | # For VM/RM we don't want shell expansion to hapen locally but remotely
|
|---|
| 2744 | my $delim = '\'';
|
|---|
| 2745 | if ($cmt =~ /^VEbuild/) {
|
|---|
| 2746 | # For VE we need to support shell expansion locally
|
|---|
| 2747 | $delim = "";
|
|---|
| 2748 | }
|
|---|
| 2749 |
|
|---|
| 2750 | open(KEEP,"> $ENV{'PBBUILDDIR'}/pbgen-$ENV{'PBPROJVER'}-$ENV{'PBPROJTAG'}-$pbos->{'name'}-$pbos->{'version'}-$pbos->{'arch'}") || die "Unable to write $ENV{'PBBUILDDIR'}/pbgen-$ENV{'PBPROJVER'}-$ENV{'PBPROJTAG'}-$pbos->{'name'}-$pbos->{'version'}-$pbos->{'arch'}";
|
|---|
| 2751 | foreach my $p (split(/ +/,$src)) {
|
|---|
| 2752 | my $j = basename($p);
|
|---|
| 2753 | pb_system("$cpcmd $cp2target/$delim$p$delim $ENV{'PBBUILDDIR'}/$pbos->{'name'}/$pbos->{'version'}/$pbos->{'arch'} 2> /dev/null","Recovery of package $j in $ENV{'PBBUILDDIR'}/$pbos->{'name'}/$pbos->{'version'}/$pbos->{'arch'}");
|
|---|
| 2754 | $made="$made $pbos->{'name'}/$pbos->{'version'}/$pbos->{'arch'}/$j"; # if (($pbos->{'type'} ne "rpm") || ($j !~ /.src.rpm$/));
|
|---|
| 2755 | }
|
|---|
| 2756 |
|
|---|
| 2757 | print KEEP "$made\n";
|
|---|
| 2758 | close(KEEP);
|
|---|
| 2759 | if (($cmt =~ /^VE/) && ($vetype eq "docker") && ($pbstep >= 3)) {
|
|---|
| 2760 | pb_rm_rf("$cp2target");
|
|---|
| 2761 | pb_system("$cmd1 rm $pbos->{'name'}-$pbos->{'version'}-$pbos->{'arch'}-$cmt","","quiet");
|
|---|
| 2762 | } else {
|
|---|
| 2763 | pb_system("$shcmdbase \"rm -rf $tdir $bdir\"","$cmt cleanup");
|
|---|
| 2764 | }
|
|---|
| 2765 |
|
|---|
| 2766 | # Sign packages locally
|
|---|
| 2767 | pb_sign_pkgs($pbos,$made);
|
|---|
| 2768 |
|
|---|
| 2769 | # We want to send them to the ssh account so overwrite what has been done before
|
|---|
| 2770 | pb_log(2,"Before sending pkgs, vexist: $vexist, vpid: $vpid\n");
|
|---|
| 2771 | pb_send2target("Packages","$ENV{'PBDESTDIR'}/pbscript.$$",$pbos->{'name'}."-".$pbos->{'version'}."-".$pbos->{'arch'},$vexist,$vpid);
|
|---|
| 2772 | pb_rm_rf("$ENV{'PBBUILDDIR'}/$pbos->{'name'}/$pbos->{'version'}/$pbos->{'arch'}");
|
|---|
| 2773 | }
|
|---|
| 2774 | }
|
|---|
| 2775 | unlink("$pbscript{$v}") if ((($cmt =~ /^(V[ME]|RM)/) || ($cmt =~ /Packages/)) && ($pbkeep eq 0) && ($cmt !~ /Script/));
|
|---|
| 2776 |
|
|---|
| 2777 | pb_log(2,"Before halt, vexist: $vexist, vpid: $vpid\n");
|
|---|
| 2778 | if ((! $vexist) && ($cmt =~ /^VM/)) {
|
|---|
| 2779 | # If in setupvm then takes a snapshot just before halting
|
|---|
| 2780 | if ($snapme != 0) {
|
|---|
| 2781 | my ($vmmonport,$vmtype) = pb_conf_get("vmmonport","vmtype");
|
|---|
| 2782 | # For monitoring control
|
|---|
| 2783 | if ((($vmtype->{$ENV{'PBPROJ'}}) eq "kvm") || (($vmtype->{$ENV{'PBPROJ'}}) eq "qemu")) {
|
|---|
| 2784 | eval
|
|---|
| 2785 | {
|
|---|
| 2786 | require Net::Telnet;
|
|---|
| 2787 | Net::Telnet->import();
|
|---|
| 2788 | };
|
|---|
| 2789 | if ($@) {
|
|---|
| 2790 | # Net::Telnet not found
|
|---|
| 2791 | pb_log(1,"ADVISE: Install Net::Telnet to benefit from monitoring control and snapshot feature.\nWARNING: No snapshot created");
|
|---|
| 2792 | } else {
|
|---|
| 2793 | my $t = new Net::Telnet (Timeout => 120, Host => "localhost", Port => $vmmonport->{$ENV{'PBPROJ'}}) || die "Unable to dialog on the monitor";
|
|---|
| 2794 | # move to monitor mode
|
|---|
| 2795 | my @lines = $t->cmd("c");
|
|---|
| 2796 | # Create a snapshot named pb
|
|---|
| 2797 | @lines = $t->cmd("savevm pb");
|
|---|
| 2798 | # Write the new status in the VM
|
|---|
| 2799 | @lines = $t->cmd("commit all");
|
|---|
| 2800 | # End
|
|---|
| 2801 | @lines = $t->cmd("quit");
|
|---|
| 2802 | }
|
|---|
| 2803 | }
|
|---|
| 2804 | }
|
|---|
| 2805 | my $hoption = "-p";
|
|---|
| 2806 | my $hpath = pb_distro_get_param($pbos,pb_conf_get("ospathcmd-halt"));
|
|---|
| 2807 | # Solaris doesn't support -p of halt
|
|---|
| 2808 | if ($pbos->{'type'} eq "pkg") {
|
|---|
| 2809 | $hoption = "" ;
|
|---|
| 2810 | }
|
|---|
| 2811 | 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)");
|
|---|
| 2812 | }
|
|---|
| 2813 | if (($cmt =~ /^VE/) && ($snapme != 0)) {
|
|---|
| 2814 | if ($vetype eq "docker") {
|
|---|
| 2815 | foreach my $f (split(/ +/,$src)) {
|
|---|
| 2816 | unlink("$context/$f");
|
|---|
| 2817 | }
|
|---|
| 2818 | } else {
|
|---|
| 2819 | pb_ve_snap($pbos,$tp);
|
|---|
| 2820 | }
|
|---|
| 2821 | }
|
|---|
| 2822 | }
|
|---|
| 2823 |
|
|---|
| 2824 | sub pb_script2v {
|
|---|
| 2825 |
|
|---|
| 2826 | my $pbscript=shift;
|
|---|
| 2827 | my $vtype=shift;
|
|---|
| 2828 | my $pbstep=shift; # Which step are we in (0: create, 1: setup pb, 2: prep pbproj, 3: use to build)
|
|---|
| 2829 | my $pbforce=shift; # Force stop of VM. Default not.
|
|---|
| 2830 | my $snapme=shift; # Do we have to create a snapshot. Default not.
|
|---|
| 2831 | my $pbimage=shift; # Which image to use to start the VM/VE
|
|---|
| 2832 |
|
|---|
| 2833 | $pbforce = 0 if (not defined $pbforce);
|
|---|
| 2834 | $snapme = 0 if (not defined $snapme);
|
|---|
| 2835 | $pbstep = 3 if (not defined $pbstep);
|
|---|
| 2836 |
|
|---|
| 2837 | pb_log(2,"DEBUG: pb_script2v($vtype,$pbstep,$pbforce,$snapme)\n");
|
|---|
| 2838 | pb_log(2,"DEBUG: pb_script2v(pbscript: ".Dumper($pbscript)."\n") if (defined $pbscript);
|
|---|
| 2839 | pb_parallel_launchv($pbscript,$vtype,uc($vtype)."Script",$pbstep,$pbimage,$pbforce,$snapme,$pbsnap);
|
|---|
| 2840 | }
|
|---|
| 2841 |
|
|---|
| 2842 | sub pb_parallel_launchv {
|
|---|
| 2843 |
|
|---|
| 2844 | my $pbscript=shift;
|
|---|
| 2845 | my $vtype = shift;
|
|---|
| 2846 | my $action = shift; # It an action is defined then use send2target
|
|---|
| 2847 | my $pbstep=shift; # Which step are we in (0: create, 1: setup, 2: build 3: use)
|
|---|
| 2848 | my $pbimage=shift; # Which image to use to start the VM/VE
|
|---|
| 2849 | my $pbforce=shift; # Force stop of VM. Default not.
|
|---|
| 2850 | my $snapme = shift; # By default do not snap a VM/VE/RM
|
|---|
| 2851 | my $usesnap = shift; # By default study the usage of the snapshot feature of VM/VE/RM
|
|---|
| 2852 | my $vm;
|
|---|
| 2853 | my $all;
|
|---|
| 2854 |
|
|---|
| 2855 | $pbforce = 0 if (not defined $pbforce);
|
|---|
| 2856 | $snapme = 0 if (not defined $snapme);
|
|---|
| 2857 | $usesnap = 1 if (not defined $usesnap);
|
|---|
| 2858 |
|
|---|
| 2859 | # Adapt // mode to memory size
|
|---|
| 2860 | $pbparallel = pb_set_parallel($vtype);
|
|---|
| 2861 |
|
|---|
| 2862 | pb_log(2,"DEBUG: pb_parallel_launch(vtype,step,force,snapme,usesnap: $vtype,$pbstep,$pbforce,$snapme,$usesnap)\n");
|
|---|
| 2863 | pb_log(2,"DEBUG: pb_parallel_launch(pbscript: ".Dumper($pbscript)."\n");
|
|---|
| 2864 |
|
|---|
| 2865 | my ($vexist,$vpid) = (undef,undef);
|
|---|
| 2866 | my $pm;
|
|---|
| 2867 | my $all_ok = 1;
|
|---|
| 2868 | if (defined $pbparallel) {
|
|---|
| 2869 | $pm = new Parallel::ForkManager($pbparallel);
|
|---|
| 2870 |
|
|---|
| 2871 | # Set which port the VM/RM will use to communicate
|
|---|
| 2872 | $pm->run_on_start(\&pb_set_port);
|
|---|
| 2873 | $pm->run_on_finish(sub { my ($pid, $code, $id, $signal, $dump) = @_;
|
|---|
| 2874 | unless ($code == 0 && $signal == 0 && $dump == 0) {
|
|---|
| 2875 | $all_ok = 0;
|
|---|
| 2876 | pb_log(0,"ERROR: pid $pid failed\n");
|
|---|
| 2877 | }
|
|---|
| 2878 | });
|
|---|
| 2879 | }
|
|---|
| 2880 |
|
|---|
| 2881 | # Determine on which V to work
|
|---|
| 2882 | if (defined $ENV{'PBV'}) {
|
|---|
| 2883 | @$vm = split(/,/,$ENV{'PBV'});
|
|---|
| 2884 | } else {
|
|---|
| 2885 | ($vm,$all) = pb_get2v($vtype);
|
|---|
| 2886 | }
|
|---|
| 2887 |
|
|---|
| 2888 | my $counter = 0;
|
|---|
| 2889 | foreach my $v (@$vm) {
|
|---|
| 2890 | $counter++;
|
|---|
| 2891 | # Modulo 2 * pbparallel (to avoid synchronization problems)
|
|---|
| 2892 | $counter = 1 if ((defined $pbparallel) && ($counter > 2 * $pbparallel));
|
|---|
| 2893 | $pm->start($counter) and next if (defined $pbparallel);
|
|---|
| 2894 |
|
|---|
| 2895 | # If launched via script2v then get the script passed as the one for the that VM
|
|---|
| 2896 | if (not defined $pbscript->{$v}) {
|
|---|
| 2897 | $pbscript->{$v} = $pbscript->{'default'};
|
|---|
| 2898 | }
|
|---|
| 2899 | #
|
|---|
| 2900 | # Launch a single operation
|
|---|
| 2901 | ($vexist,$vpid) = pb_launchv($pbscript->{$v},$vtype,$v,$action,$pbstep,$pbforce,$snapme,$pbsnap,$pbimage);
|
|---|
| 2902 |
|
|---|
| 2903 | # Skip that VM/RM if something went wrong
|
|---|
| 2904 | if (($vtype =~ /(v|r)m/) && ($vpid == 0) && ($vexist == 0)) {
|
|---|
| 2905 | $pm->finish if (defined $pbparallel);
|
|---|
| 2906 | next;
|
|---|
| 2907 | }
|
|---|
| 2908 |
|
|---|
| 2909 |
|
|---|
| 2910 | $pm->finish if (defined $pbparallel);
|
|---|
| 2911 | }
|
|---|
| 2912 | $pm->wait_all_children if (defined $pbparallel);
|
|---|
| 2913 | die "Aborting, one or more of the children failed." if ((not $all_ok) && ($Global::pb_stop_on_error));
|
|---|
| 2914 | }
|
|---|
| 2915 |
|
|---|
| 2916 | sub pb_launchv {
|
|---|
| 2917 |
|
|---|
| 2918 | my $pbscript1=shift; # Just the script name to execute, not the hash
|
|---|
| 2919 | my $vtype = shift;
|
|---|
| 2920 | my $v = shift; # Only 1 VM/VE/RM treated here
|
|---|
| 2921 | my $action = shift; # It an action is defined then use send2target
|
|---|
| 2922 | my $pbstep=shift; # Which step are we in (0: create, 1: setup, 2: build 3: use)
|
|---|
| 2923 | my $pbforce=shift; # Force stop of VM. Default not.
|
|---|
| 2924 | my $snapme = shift; # By default do not snap a VM/VE/RM
|
|---|
| 2925 | my $usesnap = shift; # By default study the usage of the snapshot feature of VM/VE/RM
|
|---|
| 2926 | my $pbimage=shift; # Which image to use to start the VM/VE
|
|---|
| 2927 | my $vexist = undef;
|
|---|
| 2928 | my $vpid = undef;
|
|---|
| 2929 |
|
|---|
| 2930 | $pbforce = 0 if (not defined $pbforce);
|
|---|
| 2931 | $snapme = 0 if (not defined $snapme);
|
|---|
| 2932 | $usesnap = 1 if (not defined $usesnap);
|
|---|
| 2933 |
|
|---|
| 2934 | # Check that v exists
|
|---|
| 2935 | die "No VM/VE/RM defined, unable to launch" if (not defined $v);
|
|---|
| 2936 |
|
|---|
| 2937 | # If creation or snapshot creation mode, no snapshot usable
|
|---|
| 2938 | if (($pbstep == 0) || ($snapme == 1)) {
|
|---|
| 2939 | $usesnap = 0;
|
|---|
| 2940 | }
|
|---|
| 2941 |
|
|---|
| 2942 | pb_log(2,"DEBUG: pb_launchv(vtype,v,step,force,snapme,usesnap: $vtype,$v,$pbstep,$pbforce,$snapme,$usesnap)\n");
|
|---|
| 2943 | pb_log(2,"DEBUG: pb_launchv(pbimage: $pbimage)\n") if (defined $pbimage);
|
|---|
| 2944 | pb_log(2,"DEBUG: pb_launchv(pbscript $pbscript1)\n") if (defined $pbscript1);
|
|---|
| 2945 | pb_log(2,"DEBUG: pb_launchv(action: $action)\n") if (defined $action);
|
|---|
| 2946 | # Keep only the first VM in case many were given
|
|---|
| 2947 | if ($v =~ /,/) {
|
|---|
| 2948 | pb_log(0,"WARNING: pruning to just the first of several VM/VE/RMs listed ($v)\n");
|
|---|
| 2949 | $v =~ s/,.*//;
|
|---|
| 2950 | }
|
|---|
| 2951 |
|
|---|
| 2952 | my $pbos = pb_distro_get_context($v);
|
|---|
| 2953 |
|
|---|
| 2954 | pb_apply_conf_proxy($pbos);
|
|---|
| 2955 |
|
|---|
| 2956 | # Launch the VMs/VEs
|
|---|
| 2957 | if ($vtype eq "vm") {
|
|---|
| 2958 | confess "-i image parameter needed" if (((not defined $pbimage) || ($pbimage eq "")) && ($pbstep == 0));
|
|---|
| 2959 |
|
|---|
| 2960 | my ($ptr,$ptr2,$vmpath,$vmport,$vms) = pb_conf_get("vmtype","vmcmd","vmpath","vmport","vmsize");
|
|---|
| 2961 | my ($vmopt,$vmmm,$vmtmout,$vmsnap,$vmbuildtm,$vmmonport) = pb_conf_get_if("vmopt","vmmem","vmtmout","vmsnap","vmbuildtm","vmmonport");
|
|---|
| 2962 | my $vmsize = pb_distro_get_param($pbos,$vms);
|
|---|
| 2963 |
|
|---|
| 2964 | my $vmtype = $ptr->{$ENV{'PBPROJ'}};
|
|---|
| 2965 | my $vmcmd = $ptr2->{$ENV{'PBPROJ'}};
|
|---|
| 2966 |
|
|---|
| 2967 | if (defined $opts{'g'}) {
|
|---|
| 2968 | if (($vmtype eq "kvm") || ($vmtype eq "qemu")) {
|
|---|
| 2969 | $ENV{'PBVMOPT'} = "--nographic";
|
|---|
| 2970 | }
|
|---|
| 2971 | }
|
|---|
| 2972 | if (not defined $ENV{'PBVMOPT'}) {
|
|---|
| 2973 | $ENV{'PBVMOPT'} = "";
|
|---|
| 2974 | }
|
|---|
| 2975 | # Save the current status for later restoration
|
|---|
| 2976 | $ENV{'PBOLDVMOPT'} = $ENV{'PBVMOPT'};
|
|---|
| 2977 | # Set a default timeout of 2 minutes
|
|---|
| 2978 | if (not defined $ENV{'PBVMTMOUT'}) {
|
|---|
| 2979 | $ENV{'PBVMTMOUT'} = "120";
|
|---|
| 2980 | }
|
|---|
| 2981 | if (defined $vmopt->{$v}) {
|
|---|
| 2982 | $ENV{'PBVMOPT'} .= " $vmopt->{$v}" if ($ENV{'PBVMOPT'} !~ / $vmopt->{$v}/);
|
|---|
| 2983 | } elsif (defined $vmopt->{$ENV{'PBPROJ'}}) {
|
|---|
| 2984 | $ENV{'PBVMOPT'} .= " $vmopt->{$ENV{'PBPROJ'}}" if ($ENV{'PBVMOPT'} !~ / $vmopt->{$ENV{'PBPROJ'}}/);
|
|---|
| 2985 | }
|
|---|
| 2986 |
|
|---|
| 2987 | # How much memory to allocate for VMs
|
|---|
| 2988 | if (defined $vmmm) {
|
|---|
| 2989 | my $vmmem = pb_distro_get_param($pbos,$vmmm);
|
|---|
| 2990 | if (defined $vmmem) {
|
|---|
| 2991 | $ENV{'PBVMOPT'} .= " -m $vmmem";
|
|---|
| 2992 | }
|
|---|
| 2993 | }
|
|---|
| 2994 |
|
|---|
| 2995 | # Are we allowed to use snapshot feature
|
|---|
| 2996 | if ($usesnap == 1) {
|
|---|
| 2997 | if ((defined $vmsnap->{$v}) && ($vmsnap->{$v} =~ /true/i)) {
|
|---|
| 2998 | $ENV{'PBVMOPT'} .= " -snapshot";
|
|---|
| 2999 | } elsif ((defined $vmsnap->{$ENV{'PBPROJ'}}) && ($vmsnap->{$ENV{'PBPROJ'}} =~ /true/i)) {
|
|---|
| 3000 | $ENV{'PBVMOPT'} .= " -snapshot";
|
|---|
| 3001 | } elsif ($pbsnap eq 1) {
|
|---|
| 3002 | $ENV{'PBVMOPT'} .= " -snapshot";
|
|---|
| 3003 | }
|
|---|
| 3004 | }
|
|---|
| 3005 | if ($snapme != 0) {
|
|---|
| 3006 | if (($vmtype eq "kvm") || ($vmtype eq "qemu")) {
|
|---|
| 3007 | # Configure the monitoring to automate the creation of the 'pb' snapshot
|
|---|
| 3008 | $ENV{'PBVMOPT'} .= " -serial mon:telnet::$vmmonport->{$ENV{'PBPROJ'}},server,nowait" if ((defined $vmmonport) && (defined $vmmonport->{$ENV{'PBPROJ'}}));
|
|---|
| 3009 | # In that case no snapshot call needed
|
|---|
| 3010 | $ENV{'PBVMOPT'} =~ s/ -snapshot//;
|
|---|
| 3011 | }
|
|---|
| 3012 | }
|
|---|
| 3013 | if (defined $vmtmout->{$v}) {
|
|---|
| 3014 | $ENV{'PBVMTMOUT'} = $vmtmout->{$v};
|
|---|
| 3015 | } elsif (defined $vmtmout->{$ENV{'PBPROJ'}}) {
|
|---|
| 3016 | $ENV{'PBVMTMOUT'} = $vmtmout->{$ENV{'PBPROJ'}};
|
|---|
| 3017 | }
|
|---|
| 3018 | my $nport = pb_get_port($vmport,$pbos,$vtype);
|
|---|
| 3019 |
|
|---|
| 3020 | my $cmd;
|
|---|
| 3021 | my $vmm; # has to be used for pb_check_ps
|
|---|
| 3022 | if (($vmtype eq "qemu") || ($vmtype eq "kvm")) {
|
|---|
| 3023 | $vmm = "$vmpath->{$ENV{'PBPROJ'}}/$v.qemu";
|
|---|
| 3024 | if (($pbstep == 0) || (defined $pbimage)) {
|
|---|
| 3025 | $ENV{'PBVMOPT'} .= " -cdrom $pbimage -boot d";
|
|---|
| 3026 | }
|
|---|
| 3027 | # Always redirect the network and always try to use a 'pb' snapshot
|
|---|
| 3028 | #$cmd = "$vmcmd $ENV{'PBVMOPT'} -net nic,model=virtio -net user,hostfwd=tcp::$nport:22 -loadvm pb $vmm"
|
|---|
| 3029 | #$cmd = "$vmcmd $ENV{'PBVMOPT'} -redir tcp:$nport:10.0.2.15:22 $vmm"
|
|---|
| 3030 | $cmd = "$vmcmd $ENV{'PBVMOPT'} -net nic -net user,hostfwd=tcp:127.0.0.1:$nport-:22 $vmm"
|
|---|
| 3031 | } elsif ($vmtype eq "xen") {
|
|---|
| 3032 | } elsif ($vmtype eq "vmware") {
|
|---|
| 3033 | } else {
|
|---|
| 3034 | die "VM of type $vmtype not supported. Report to the dev team";
|
|---|
| 3035 | }
|
|---|
| 3036 | # Restore the ENV VAR Value
|
|---|
| 3037 | $ENV{'PBVMOPT'} = $ENV{'PBOLDVMOPT'};
|
|---|
| 3038 |
|
|---|
| 3039 | my ($tmpcmd,$void) = split(/ +/,$cmd);
|
|---|
| 3040 | my $vmmport = undef;
|
|---|
| 3041 | ($vexist,$vmmport) = pb_check_ps($tmpcmd,$vmm);
|
|---|
| 3042 | $vpid = 0;
|
|---|
| 3043 |
|
|---|
| 3044 | if (! $vexist) {
|
|---|
| 3045 | if ($pbstep == 0) {
|
|---|
| 3046 | die("Found an existing Virtual machine $vmm. Won't overwrite") if (-r $vmm);
|
|---|
| 3047 | if (($vmtype eq "qemu") || ($vmtype eq "xen") || ($vmtype eq "kvm")) {
|
|---|
| 3048 | my $command = pb_check_req("qemu-img",0);
|
|---|
| 3049 | pb_system("$command create -f qcow2 $vmm $vmsize","Creating the QEMU VM");
|
|---|
| 3050 | } elsif ($vmtype eq "vmware") {
|
|---|
| 3051 | } else {
|
|---|
| 3052 | }
|
|---|
| 3053 | }
|
|---|
| 3054 | if (! -f "$vmm") {
|
|---|
| 3055 | pb_log(0,"Unable to find VM $vmm\n");
|
|---|
| 3056 | } else {
|
|---|
| 3057 | # Is the SSH port free? if not kill the existing process using it after a build timeout period
|
|---|
| 3058 | my ($vmssh,$void) = pb_check_ps($tmpcmd,$vmm);
|
|---|
| 3059 | if ($vmssh) {
|
|---|
| 3060 | my $buildtm = $ENV{'PBVMTMOUT'};
|
|---|
| 3061 | if (defined $vmbuildtm->{$v}) {
|
|---|
| 3062 | $buildtm = $vmbuildtm->{$v};
|
|---|
| 3063 | } elsif (defined $vmbuildtm->{$ENV{'PBPROJ'}}) {
|
|---|
| 3064 | $buildtm = $vmbuildtm->{$ENV{'PBPROJ'}};
|
|---|
| 3065 | }
|
|---|
| 3066 |
|
|---|
| 3067 | sleep $buildtm;
|
|---|
| 3068 | pb_log(0,"WARNING: Killing the process ($vmssh) using port $void (previous failed VM ?)\n");
|
|---|
| 3069 | kill 15,$vmssh;
|
|---|
| 3070 | # Let it time to exit
|
|---|
| 3071 | sleep 5;
|
|---|
| 3072 | }
|
|---|
| 3073 | pb_system("$cmd &","Launching the VM $vmm");
|
|---|
| 3074 | # Using system allows to kill it externaly if needed,sosupport that in the call
|
|---|
| 3075 | pb_system("sleep $ENV{'PBVMTMOUT'}","Waiting $ENV{'PBVMTMOUT'} s for VM $v to come up","mayfail");
|
|---|
| 3076 | ($vpid,$void) = pb_check_ps($tmpcmd,$vmm);
|
|---|
| 3077 | pb_log(0,"VM $vmm launched (pid $vpid)\n");
|
|---|
| 3078 | }
|
|---|
| 3079 | } else {
|
|---|
| 3080 | pb_log(0,"Found an existing VM $vmm (pid $vexist - Port $vmmport)\n");
|
|---|
| 3081 | # Set the correct port here based on what is done
|
|---|
| 3082 | $pbport = $vmmport;
|
|---|
| 3083 | $vpid = $vexist;
|
|---|
| 3084 | }
|
|---|
| 3085 | pb_log(2,"DEBUG: pb_launchv returns ($vexist,$vpid)\n");
|
|---|
| 3086 |
|
|---|
| 3087 | # After the VM is launched, then setup the SSH access if not in creation phase
|
|---|
| 3088 | if ($pbstep != 0) {
|
|---|
| 3089 | if (defined $pbport) {
|
|---|
| 3090 | pb_ssh_setup($vtype,$pbport);
|
|---|
| 3091 | } else {
|
|---|
| 3092 | pb_ssh_setup($vtype,$nport);
|
|---|
| 3093 | }
|
|---|
| 3094 | }
|
|---|
| 3095 |
|
|---|
| 3096 | # Skip that VM if something went wrong
|
|---|
| 3097 | return($vexist,$vpid) if (($vpid == 0) && ($vexist == 0));
|
|---|
| 3098 |
|
|---|
| 3099 | # If force stopping the VM then reset vexist
|
|---|
| 3100 | if ($pbforce == 1) {
|
|---|
| 3101 | $vpid = $vexist;
|
|---|
| 3102 | $vexist = 0;
|
|---|
| 3103 | }
|
|---|
| 3104 | } elsif ($vtype eq "ve") {
|
|---|
| 3105 | # Force the creation of the VE and no snapshot usable
|
|---|
| 3106 | $vetype = pb_ve_get_type($vetype);
|
|---|
| 3107 | pb_ve_launch($v,$pbstep,$usesnap,$vetype,$pbimage);
|
|---|
| 3108 | $vexist = 0;
|
|---|
| 3109 | $vpid = 0;
|
|---|
| 3110 | } else {
|
|---|
| 3111 | # Get RM context
|
|---|
| 3112 | my ($ptr,$rmpath,$rmport) = pb_conf_get("rmtype","rmpath","rmport");
|
|---|
| 3113 |
|
|---|
| 3114 | # Nothing more to do for RM. No real launch
|
|---|
| 3115 | # For the moment we support the RM is already running
|
|---|
| 3116 | # For ProLiant may be able to power them on if needed later on as an example.
|
|---|
| 3117 | $vexist = 0;
|
|---|
| 3118 | $vpid = 0;
|
|---|
| 3119 |
|
|---|
| 3120 | # After the RM is launched, then setup the SSH access
|
|---|
| 3121 | my $nport = pb_get_port($rmport,$pbos,$vtype);
|
|---|
| 3122 | pb_ssh_setup($vtype,$nport);
|
|---|
| 3123 | }
|
|---|
| 3124 |
|
|---|
| 3125 | # Gather all required files to send them to the VM/VE/RM
|
|---|
| 3126 | # and launch the build through pbscript
|
|---|
| 3127 | if (defined $action) {
|
|---|
| 3128 | pb_log(2,"DEBUG: Before send2target, vexist: $vexist, vpid: $vpid, vtype: $vtype, v: $v, action: $action\n");
|
|---|
| 3129 | pb_send2target($action,$pbscript1,$v,$vexist,$vpid,$snapme,$pbstep);
|
|---|
| 3130 | }
|
|---|
| 3131 | return($vexist,$vpid);
|
|---|
| 3132 | }
|
|---|
| 3133 |
|
|---|
| 3134 | # Return string for date synchro
|
|---|
| 3135 | sub pb_date2v {
|
|---|
| 3136 |
|
|---|
| 3137 | my $vtype = shift;
|
|---|
| 3138 | my $pbos = shift;
|
|---|
| 3139 | my $nontp = shift || 0;
|
|---|
| 3140 |
|
|---|
| 3141 | pb_log(1,"Entering pb_date2v\n");
|
|---|
| 3142 | # VE gets time from parent OS.
|
|---|
| 3143 | return "/bin/true" if ($vtype) =~ /^ve/o;
|
|---|
| 3144 |
|
|---|
| 3145 | my ($ntp) = pb_conf_get_if($vtype."ntp");
|
|---|
| 3146 | my $vntp = undef;
|
|---|
| 3147 | my $ntpline = undef;
|
|---|
| 3148 | $vntp = $ntp->{$ENV{'PBPROJ'}} if (defined $ntp);
|
|---|
| 3149 |
|
|---|
| 3150 | if ((defined $vntp) && ($vntp !~ /^\s*$/)) {
|
|---|
| 3151 | pb_log(2,"ntp server is $vntp\n");
|
|---|
| 3152 | # ntp command depends on pbos
|
|---|
| 3153 | my $vntpcmd = pb_distro_get_param($pbos,pb_conf_get("oscmdntp"));
|
|---|
| 3154 | $ntpline = "sudo $vntpcmd $vntp";
|
|---|
| 3155 | }
|
|---|
| 3156 | # Force new date to be in the future compared to the date
|
|---|
| 3157 | # of the host by adding 1 minute
|
|---|
| 3158 | my @date=pb_get_date();
|
|---|
| 3159 | $date[1]++;
|
|---|
| 3160 | my $upddate = strftime("%m%d%H%M%Y", @date);
|
|---|
| 3161 | my $dateline = "sudo /bin/date $upddate";
|
|---|
| 3162 | if ((defined $ntpline) && ($nontp == 0)) {
|
|---|
| 3163 | pb_log(1,"pb_date2v returns $ntpline\n");
|
|---|
| 3164 | return($ntpline);
|
|---|
| 3165 | } else {
|
|---|
| 3166 | pb_log(1,"pb_date2v returns $dateline\n");
|
|---|
| 3167 | return($dateline);
|
|---|
| 3168 | }
|
|---|
| 3169 | }
|
|---|
| 3170 |
|
|---|
| 3171 | sub pb_build2v {
|
|---|
| 3172 |
|
|---|
| 3173 | my $vtype = shift;
|
|---|
| 3174 | my $action = shift; #build, test or prep
|
|---|
| 3175 | my $pbforce=shift; # Force stop of VM. Default not.
|
|---|
| 3176 |
|
|---|
| 3177 | $action = "build" if (not defined $action);
|
|---|
| 3178 | $pbforce = 0 if (not defined $pbforce);
|
|---|
| 3179 |
|
|---|
| 3180 | my $pbstep;
|
|---|
| 3181 |
|
|---|
| 3182 | $vetype = pb_ve_get_type($vetype);
|
|---|
| 3183 | if ($action eq "prep") {
|
|---|
| 3184 | $pbstep = 2;
|
|---|
| 3185 | } else {
|
|---|
| 3186 | $pbstep = 3;
|
|---|
| 3187 | # Need to be traversed by others if using containers
|
|---|
| 3188 | if (($vtype eq "ve") && ($vetype eq "docker")) {
|
|---|
| 3189 | chmod 0751,"$ENV{'PBBUILDDIR'}";
|
|---|
| 3190 | }
|
|---|
| 3191 | }
|
|---|
| 3192 |
|
|---|
| 3193 | pb_log(1,"Entering in pb_build2v ($action in $vtype) \n");
|
|---|
| 3194 |
|
|---|
| 3195 | # We prepare scripts for all V of this vtype to allow sharing that part
|
|---|
| 3196 | my ($v,$all) = pb_get2v($vtype);
|
|---|
| 3197 |
|
|---|
| 3198 | # Send tar files when we do a global generation
|
|---|
| 3199 | pb_build2ssh() if (($all == 1) && ($action eq "build"));
|
|---|
| 3200 |
|
|---|
| 3201 | # Adapt // mode to memory size
|
|---|
| 3202 | $pbparallel = pb_set_parallel($vtype);
|
|---|
| 3203 |
|
|---|
| 3204 | my ($vexist,$vpid) = (undef,undef);
|
|---|
| 3205 | my $pm;
|
|---|
| 3206 | my $all_ok = 1;
|
|---|
| 3207 | if (defined $pbparallel) {
|
|---|
| 3208 | $pm = new Parallel::ForkManager($pbparallel);
|
|---|
| 3209 |
|
|---|
| 3210 | # Set which port the VM/RM will use to communicate
|
|---|
| 3211 | $pm->run_on_start(\&pb_set_port);
|
|---|
| 3212 | $pm->run_on_finish(sub { my ($pid, $code, $id, $signal, $dump) = @_;
|
|---|
| 3213 | unless ($code == 0 && $signal == 0 && $dump == 0) {
|
|---|
| 3214 | $all_ok = 0;
|
|---|
| 3215 | pb_log(0,"ERROR: pid $pid failed\n");
|
|---|
| 3216 | }
|
|---|
| 3217 | });
|
|---|
| 3218 | }
|
|---|
| 3219 |
|
|---|
| 3220 | my $counter = 0;
|
|---|
| 3221 | foreach my $v (@$v) {
|
|---|
| 3222 | $counter++;
|
|---|
| 3223 | $pbscript{$v} = "$ENV{'PBDESTDIR'}/pb$action-$v";
|
|---|
| 3224 | # Modulo 2 * pbparallel (to avoid synchronization problems)
|
|---|
| 3225 | $counter = 1 if ((defined $pbparallel) && ($counter > 2 * $pbparallel));
|
|---|
| 3226 | $pm->start($counter) and next if (defined $pbparallel);
|
|---|
| 3227 | #
|
|---|
| 3228 | # Prepare the script to be executed on the VM/VE/RM
|
|---|
| 3229 | open(SCRIPT,"> $pbscript{$v}") || die "Unable to create $pbscript{$v}";
|
|---|
| 3230 | print SCRIPT "#!/bin/bash\n";
|
|---|
| 3231 |
|
|---|
| 3232 | # Transmit the verbosity level to the virtual env/mach.
|
|---|
| 3233 | my $verbose = "";
|
|---|
| 3234 | my $i = 0; # minimal debug level
|
|---|
| 3235 | while ($i lt $pbdebug) {
|
|---|
| 3236 | $verbose .= "-v ";
|
|---|
| 3237 | $i++;
|
|---|
| 3238 | }
|
|---|
| 3239 | print SCRIPT "set -e\n" if ($Global::pb_stop_on_error);
|
|---|
| 3240 | # Activate script verbosity if at least 2 for pbdebug
|
|---|
| 3241 | print SCRIPT "set -x\n" if ($i gt 1);
|
|---|
| 3242 | # Quiet if asked to be so on the original system
|
|---|
| 3243 | $verbose = "-q" if ($pbdebug eq -1);
|
|---|
| 3244 |
|
|---|
| 3245 | print SCRIPT "echo ... Execution needed\n";
|
|---|
| 3246 | print SCRIPT "echo ==== Start of script for $vtype $v =====\n";
|
|---|
| 3247 | print SCRIPT "# This is in directory pbdelivery\n";
|
|---|
| 3248 | print SCRIPT "# Setup the variables required for building\n";
|
|---|
| 3249 | print SCRIPT "export PBPROJ=$ENV{'PBPROJ'}\n";
|
|---|
| 3250 |
|
|---|
| 3251 | if (($action eq "build") || ($action eq "prep")) {
|
|---|
| 3252 | print SCRIPT "# Preparation for pb\n";
|
|---|
| 3253 | print SCRIPT "rm -f \$HOME/.pbrc\n";
|
|---|
| 3254 | print SCRIPT "cp .pbrc \$HOME\n";
|
|---|
| 3255 | # TODO: Why ?
|
|---|
| 3256 | print SCRIPT "cd ..\n";
|
|---|
| 3257 | }
|
|---|
| 3258 |
|
|---|
| 3259 | # VE needs a good /proc, tolerate one being potentially left around after a failure
|
|---|
| 3260 | if (($vtype eq "ve") && ($vetype ne "docker")) {
|
|---|
| 3261 | print SCRIPT "[ -d /proc/1 ] || sudo /bin/mount -t proc /proc /proc\n";
|
|---|
| 3262 | }
|
|---|
| 3263 |
|
|---|
| 3264 | # Get distro context
|
|---|
| 3265 | my $pbos = pb_distro_get_context($v);
|
|---|
| 3266 |
|
|---|
| 3267 | my $ntpline = pb_date2v($vtype,$pbos);
|
|---|
| 3268 | print SCRIPT "# Time sync\n";
|
|---|
| 3269 | print SCRIPT "echo setting up date with $ntpline\n";
|
|---|
| 3270 | print SCRIPT "$ntpline\n";
|
|---|
| 3271 | print SCRIPT "if [ \$\? -ne 0 ]; then\n";
|
|---|
| 3272 | # Force if bad status a trick using date
|
|---|
| 3273 | $ntpline = pb_date2v($vtype,$pbos, 1);
|
|---|
| 3274 | print SCRIPT " $ntpline\n";
|
|---|
| 3275 | print SCRIPT "fi\n";
|
|---|
| 3276 | # Use potential local proxy declaration in case we need it to download repo, pkgs, ...
|
|---|
| 3277 | if (defined $ENV{'http_proxy'}) {
|
|---|
| 3278 | print SCRIPT "export http_proxy=\"$ENV{'http_proxy'}\"\n";
|
|---|
| 3279 | }
|
|---|
| 3280 |
|
|---|
| 3281 | if (defined $ENV{'ftp_proxy'}) {
|
|---|
| 3282 | print SCRIPT "export ftp_proxy=\"$ENV{'ftp_proxy'}\"\n";
|
|---|
| 3283 | }
|
|---|
| 3284 |
|
|---|
| 3285 | # Get list of packages to build/test and get some ENV vars as well
|
|---|
| 3286 | my $ptr = pb_get_pkg();
|
|---|
| 3287 | @pkgs = @$ptr;
|
|---|
| 3288 | my $p = join(' ',@pkgs) if (@pkgs);
|
|---|
| 3289 | print SCRIPT "export PBPROJVER=$ENV{'PBPROJVER'}\n";
|
|---|
| 3290 | print SCRIPT "export PBPROJTAG=$ENV{'PBPROJTAG'}\n";
|
|---|
| 3291 | print SCRIPT "export PBPACKAGER=\"$ENV{'PBPACKAGER'}\"\n";
|
|---|
| 3292 |
|
|---|
| 3293 | # We may need to do some other tasks before building. Read a script here to finish setup
|
|---|
| 3294 | if (-x "$ENV{'PBDESTDIR'}/pb$vtype".".pre") {
|
|---|
| 3295 | print SCRIPT "# Special pre-instructions to be launched\n";
|
|---|
| 3296 | print SCRIPT pb_get_content("$ENV{'PBDESTDIR'}/pb$vtype".".pre");
|
|---|
| 3297 | }
|
|---|
| 3298 |
|
|---|
| 3299 | if (-x "$ENV{'PBDESTDIR'}/pb$vtype"."$action.pre") {
|
|---|
| 3300 | print SCRIPT "# Special pre-$action instructions to be launched\n";
|
|---|
| 3301 | print SCRIPT pb_get_content("$ENV{'PBDESTDIR'}/pb$vtype"."$action.pre");
|
|---|
| 3302 | }
|
|---|
| 3303 |
|
|---|
| 3304 | print SCRIPT "# $action\n";
|
|---|
| 3305 | print SCRIPT "echo $action"."ing packages on $vtype...\n";
|
|---|
| 3306 |
|
|---|
| 3307 | if (($action eq "test") && (! -x "$ENV{'PBDESTDIR'}/pbtest")) {
|
|---|
| 3308 | confess "No test script ($ENV{'PBDESTDIR'}/pbtest) found when in test mode. Aborting ...";
|
|---|
| 3309 | }
|
|---|
| 3310 | print SCRIPT "pb -h\n";
|
|---|
| 3311 | my $act = "$action"."2pkg";
|
|---|
| 3312 | $act = "build2prep" if ($action eq "prep");
|
|---|
| 3313 | print SCRIPT "pb $verbose -p $ENV{'PBPROJ'} $act $p\n";
|
|---|
| 3314 |
|
|---|
| 3315 | if (($vtype eq "ve") && ($vetype ne "docker")) {
|
|---|
| 3316 | print SCRIPT "sudo /bin/umount /proc\n";
|
|---|
| 3317 | }
|
|---|
| 3318 |
|
|---|
| 3319 | # We may need to do some other tasks after building. Read a script here to exit properly
|
|---|
| 3320 | if (-x "$ENV{'PBDESTDIR'}/pb$vtype"."$action.post") {
|
|---|
| 3321 | print SCRIPT "# Special post-$action instructions to be launched\n";
|
|---|
| 3322 | print SCRIPT pb_get_content("$ENV{'PBDESTDIR'}/pb$vtype"."$action.post");
|
|---|
| 3323 | }
|
|---|
| 3324 |
|
|---|
| 3325 | if (-x "$ENV{'PBDESTDIR'}/pb$vtype".".post") {
|
|---|
| 3326 | print SCRIPT "# Special post-instructions to be launched\n";
|
|---|
| 3327 | print SCRIPT pb_get_content("$ENV{'PBDESTDIR'}/pb$vtype".".post");
|
|---|
| 3328 | }
|
|---|
| 3329 |
|
|---|
| 3330 | print SCRIPT "echo ==== End of script $$ for $vtype $v =====\n";
|
|---|
| 3331 | close(SCRIPT);
|
|---|
| 3332 | chmod 0755,"$pbscript{$v}";
|
|---|
| 3333 |
|
|---|
| 3334 | $pm->finish if (defined $pbparallel);
|
|---|
| 3335 | }
|
|---|
| 3336 | $pm->wait_all_children if (defined $pbparallel);
|
|---|
| 3337 | die "Aborting, one or more of the children failed." if ((not $all_ok) && ($Global::pb_stop_on_error));
|
|---|
| 3338 |
|
|---|
| 3339 | # Launch the VM/VE/RM
|
|---|
| 3340 | # docker image to use if needed
|
|---|
| 3341 | # Gather all required files to send them to the VM/VE
|
|---|
| 3342 | # and launch the build through pbscript
|
|---|
| 3343 | pb_parallel_launchv(\%pbscript,$vtype,uc($vtype).$action,$pbstep,$pbimage,$pbforce);
|
|---|
| 3344 | }
|
|---|
| 3345 |
|
|---|
| 3346 |
|
|---|
| 3347 | sub pb_clean {
|
|---|
| 3348 |
|
|---|
| 3349 | my $sleep=10;
|
|---|
| 3350 | die "Unable to get env var PBDESTDIR" if (not defined $ENV{'PBDESTDIR'});
|
|---|
| 3351 | die "Unable to get env var PBBUILDDIR" if (not defined $ENV{'PBBUILDDIR'});
|
|---|
| 3352 | pb_log(0,"We will now wait $sleep s before removing both directories\n$ENV{'PBDESTDIR'} and $ENV{'PBBUILDDIR'}.\nPlease break me if this is wrong\n");
|
|---|
| 3353 | sleep $sleep;
|
|---|
| 3354 | pb_rm_rf($ENV{'PBDESTDIR'});
|
|---|
| 3355 | pb_rm_rf($ENV{'PBBUILDDIR'});
|
|---|
| 3356 | }
|
|---|
| 3357 |
|
|---|
| 3358 | sub pb_newver {
|
|---|
| 3359 |
|
|---|
| 3360 | die "-V Version parameter needed" if ((not defined $newver) || ($newver eq ""));
|
|---|
| 3361 |
|
|---|
| 3362 | # Need this call for PBDIR
|
|---|
| 3363 | my ($scheme2,$uri) = pb_cms_init($pbinit);
|
|---|
| 3364 |
|
|---|
| 3365 | my ($pbconf,$pburl) = pb_conf_get("pbconfurl","pburl");
|
|---|
| 3366 | $uri = $pbconf->{$ENV{'PBPROJ'}};
|
|---|
| 3367 | my ($scheme, $account, $host, $port, $path) = pb_get_uri($uri);
|
|---|
| 3368 |
|
|---|
| 3369 | # Checking CMS repositories status
|
|---|
| 3370 | ($scheme2, $account, $host, $port, $path) = pb_get_uri($pburl->{$ENV{'PBPROJ'}});
|
|---|
| 3371 |
|
|---|
| 3372 | if ($scheme !~ /^svn/) {
|
|---|
| 3373 | die "Only SVN is supported at the moment";
|
|---|
| 3374 | }
|
|---|
| 3375 |
|
|---|
| 3376 | my $res = pb_vcs_isdiff($scheme,$ENV{'PBROOTDIR'});
|
|---|
| 3377 | die "ERROR: No differences accepted in CMS for $ENV{'PBROOTDIR'} before creating a new version" if ($res != 0);
|
|---|
| 3378 |
|
|---|
| 3379 | $res = pb_vcs_isdiff($scheme2,$ENV{'PBDIR'});
|
|---|
| 3380 | die "ERROR: No differences accepted in CMS for $ENV{'PBDIR'} before creating a new version" if ($res != 0);
|
|---|
| 3381 |
|
|---|
| 3382 | # Tree identical between PBCONFDIR and PBROOTDIR. The delta is what
|
|---|
| 3383 | # we want to get for the root of the new URL
|
|---|
| 3384 |
|
|---|
| 3385 | my $oldver = $ENV{'PBROOTDIR'};
|
|---|
| 3386 | $oldver =~ s|^$ENV{'PBCONFDIR'}||;
|
|---|
| 3387 |
|
|---|
| 3388 | pb_log(2, "PBCONFDIR: $ENV{'PBCONFDIR'}\nPBROOTDIR: $ENV{'PBROOTDIR'}\n");
|
|---|
| 3389 |
|
|---|
| 3390 | my $newurl = "$uri/$newver";
|
|---|
| 3391 | # Should probably use projver in the old file
|
|---|
| 3392 | my $oldvertxt= basename($oldver);
|
|---|
| 3393 | my $newvertxt = basename($newver);
|
|---|
| 3394 |
|
|---|
| 3395 | # Duplicate and extract project-builder part
|
|---|
| 3396 | pb_log(2,"Copying $uri/$oldver to $newurl\n");
|
|---|
| 3397 | pb_vcs_copy($scheme,"$uri/$oldver",$newurl);
|
|---|
| 3398 | pb_log(2,"Checkout $newurl to $ENV{'PBCONFDIR'}/$newver\n");
|
|---|
| 3399 | pb_vcs_up($scheme,"$ENV{'PBCONFDIR'}");
|
|---|
| 3400 |
|
|---|
| 3401 | # Duplicate and extract project
|
|---|
| 3402 | my $newurl2 = "$pburl->{$ENV{'PBPROJ'}}/$newver";
|
|---|
| 3403 |
|
|---|
| 3404 | pb_log(2,"Copying $pburl->{$ENV{'PBPROJ'}}/$oldver to $newurl2\n");
|
|---|
| 3405 | pb_vcs_copy($scheme2,"$pburl->{$ENV{'PBPROJ'}}/$oldver",$newurl2);
|
|---|
| 3406 |
|
|---|
| 3407 | my $tmp = $ENV{'PBDIR'};
|
|---|
| 3408 | $tmp =~ s|$oldver$||;
|
|---|
| 3409 | pb_log(2,"Checkout $newurl2 to $tmp/$newver\n");
|
|---|
| 3410 | pb_vcs_up($scheme2,"$tmp");
|
|---|
| 3411 |
|
|---|
| 3412 | # Update the .pb file
|
|---|
| 3413 | open(FILE,"$ENV{'PBCONFDIR'}/$newver/$ENV{'PBPROJ'}.pb") || die "Unable to open $ENV{'PBCONFDIR'}/$newver/$ENV{'PBPROJ'}.pb";
|
|---|
| 3414 | open(OUT,"> $ENV{'PBCONFDIR'}/$newver/$ENV{'PBPROJ'}.pb.new") || die "Unable to write to $ENV{'PBCONFDIR'}/$newver/$ENV{'PBPROJ'}.pb.new";
|
|---|
| 3415 | while(<FILE>) {
|
|---|
| 3416 | if (/^projver\s+$ENV{'PBPROJ'}\s*=\s*$oldvertxt$/) {
|
|---|
| 3417 | s/^projver\s+$ENV{'PBPROJ'}\s*=\s*$oldvertxt$/projver $ENV{'PBPROJ'} = $newvertxt/;
|
|---|
| 3418 | pb_log(0,"Changing projver from $oldvertxt to $newvertxt in $ENV{'PBCONFDIR'}/$newver/$ENV{'PBPROJ'}.pb\n");
|
|---|
| 3419 | }
|
|---|
| 3420 | if (/^testver/) {
|
|---|
| 3421 | s/^testver/#testver/;
|
|---|
| 3422 | pb_log(0,"Commenting testver in $ENV{'PBCONFDIR'}/$newver/$ENV{'PBPROJ'}.pb\n") if (/^testver/);
|
|---|
| 3423 | }
|
|---|
| 3424 | if (/^delivery/) {
|
|---|
| 3425 | my $txt = $_;
|
|---|
| 3426 | chomp($txt);
|
|---|
| 3427 | pb_log(0,"Please check delivery ($txt) in $ENV{'PBCONFDIR'}/$newver/$ENV{'PBPROJ'}.pb\n");
|
|---|
| 3428 | }
|
|---|
| 3429 | print OUT $_;
|
|---|
| 3430 | }
|
|---|
| 3431 | close(FILE);
|
|---|
| 3432 | close(OUT);
|
|---|
| 3433 | rename("$ENV{'PBCONFDIR'}/$newver/$ENV{'PBPROJ'}.pb.new","$ENV{'PBCONFDIR'}/$newver/$ENV{'PBPROJ'}.pb");
|
|---|
| 3434 |
|
|---|
| 3435 | # Checking pbcl files
|
|---|
| 3436 | foreach my $f (<$ENV{'PBROOTDIR'}/*/pbcl>) {
|
|---|
| 3437 | # Compute new pbcl file
|
|---|
| 3438 | my $f2 = $f;
|
|---|
| 3439 | $f2 =~ s|$ENV{'PBROOTDIR'}|$ENV{'PBCONFDIR'}/$newver/|;
|
|---|
| 3440 | open(PBCL,$f) || die "Unable to open $f";
|
|---|
| 3441 | my $foundnew = 0;
|
|---|
| 3442 | while (<PBCL>) {
|
|---|
| 3443 | $foundnew = 1 if (/^$newvertxt \(/);
|
|---|
| 3444 | }
|
|---|
| 3445 | close(PBCL);
|
|---|
| 3446 | open(OUT,"> $f2") || die "Unable to write to $f2: $!";
|
|---|
| 3447 | open(PBCL,$f) || die "Unable to open $f";
|
|---|
| 3448 | # We skip as long as we do not reach the new version in the log (case of devel)
|
|---|
| 3449 | my $skip = 1;
|
|---|
| 3450 | # We let the 4 first lines
|
|---|
| 3451 | my $cnt = 0;
|
|---|
| 3452 | while (<PBCL>) {
|
|---|
| 3453 | $skip = 0 if (/^$newvertxt \(/);
|
|---|
| 3454 | if ((/^$oldvertxt \(/) && ($foundnew == 0)) {
|
|---|
| 3455 | print OUT "$newvertxt ($pbdate)\n";
|
|---|
| 3456 | print OUT "- TBD\n";
|
|---|
| 3457 | print OUT "\n";
|
|---|
| 3458 | pb_log(0,"WARNING: version $newvertxt not found in $f so added to $f2...\n") if ($foundnew == 0);
|
|---|
| 3459 | }
|
|---|
| 3460 | if ($cnt <= 4) {
|
|---|
| 3461 | print OUT "$_" if (not /^$oldvertxt \(/);
|
|---|
| 3462 | } else {
|
|---|
| 3463 | print OUT "$_" if ($skip == 0);
|
|---|
| 3464 | }
|
|---|
| 3465 | $cnt++;
|
|---|
| 3466 | }
|
|---|
| 3467 | close(OUT);
|
|---|
| 3468 | close(PBCL);
|
|---|
| 3469 | }
|
|---|
| 3470 |
|
|---|
| 3471 | pb_log(2,"Checkin $ENV{'PBCONFDIR'}/$newver\n");
|
|---|
| 3472 | pb_vcs_checkin($scheme,"$ENV{'PBCONFDIR'}/$newver","updated to $ENV{'PBCONFDIR'}");
|
|---|
| 3473 | }
|
|---|
| 3474 |
|
|---|
| 3475 | #
|
|---|
| 3476 | # Return the list of VMs/VEs/RMs we are working on
|
|---|
| 3477 | # $all is a flag to know if we return all of them
|
|---|
| 3478 | # or only some (if all we publish also tar files in addition to pkgs
|
|---|
| 3479 | #
|
|---|
| 3480 | sub pb_get2v {
|
|---|
| 3481 |
|
|---|
| 3482 | my $vtype = shift;
|
|---|
| 3483 | my @v;
|
|---|
| 3484 | my $all = 0;
|
|---|
| 3485 | my $pbv = 'PBV';
|
|---|
| 3486 | my $vlist = $vtype."list";
|
|---|
| 3487 |
|
|---|
| 3488 | # Get VM/VE list
|
|---|
| 3489 | if ((not defined $ENV{$pbv}) || ($ENV{$pbv} =~ /^all$/)) {
|
|---|
| 3490 | my ($ptr) = pb_conf_get($vlist);
|
|---|
| 3491 | $ENV{$pbv} = $ptr->{$ENV{'PBPROJ'}};
|
|---|
| 3492 | $all = 1;
|
|---|
| 3493 | }
|
|---|
| 3494 | pb_log(2,"$vtype: $ENV{$pbv}\n");
|
|---|
| 3495 | @v = split(/,/,$ENV{$pbv});
|
|---|
| 3496 | return(\@v,$all);
|
|---|
| 3497 | }
|
|---|
| 3498 |
|
|---|
| 3499 | # This function creates a giant script to configure a particular VM/VE/RM, it then copies the
|
|---|
| 3500 | # script to the target.
|
|---|
| 3501 |
|
|---|
| 3502 | # Function to create a potentialy missing pb account on the VM/VE/RM, and adds it to sudo
|
|---|
| 3503 | # Needs to use root account to connect to the VM/VE/RM
|
|---|
| 3504 | # pb will take your local public SSH key to access
|
|---|
| 3505 | # the pb account in the VM/VE/RM later on if needed
|
|---|
| 3506 | sub pb_setup2v {
|
|---|
| 3507 |
|
|---|
| 3508 | my $vtype = shift;
|
|---|
| 3509 | my $sbx = shift;
|
|---|
| 3510 | my $pbstep = 1;
|
|---|
| 3511 |
|
|---|
| 3512 | my ($vm,$all) = pb_get2v($vtype);
|
|---|
| 3513 |
|
|---|
| 3514 | # Adapt // mode to memory size
|
|---|
| 3515 | $pbparallel = pb_set_parallel($vtype);
|
|---|
| 3516 |
|
|---|
| 3517 | my $pm;
|
|---|
| 3518 | my $all_ok = 1;
|
|---|
| 3519 | if (defined $pbparallel) {
|
|---|
| 3520 | $pm = new Parallel::ForkManager($pbparallel);
|
|---|
| 3521 |
|
|---|
| 3522 | # Set which port the VM/RM will use to communicate
|
|---|
| 3523 | $pm->run_on_start(\&pb_set_port);
|
|---|
| 3524 | $pm->run_on_finish(sub { my ($pid, $code, $id, $signal, $dump) = @_;
|
|---|
| 3525 | $all_ok = 0 unless (($code == 0) && ($signal == 0) && ($dump == 0));
|
|---|
| 3526 | });
|
|---|
| 3527 | }
|
|---|
| 3528 |
|
|---|
| 3529 | my $counter = 0;
|
|---|
| 3530 | foreach my $v (@$vm) {
|
|---|
| 3531 | # Script generated - should be before the fork - after the %pbscript hash isn't updated correctly
|
|---|
| 3532 | $pbscript{$v} = "$ENV{'PBDESTDIR'}/setupv-$v";
|
|---|
| 3533 |
|
|---|
| 3534 | $counter++;
|
|---|
| 3535 | # Modulo 2 * pbparallel (to avoid synchronization problems)
|
|---|
| 3536 | $counter = 1 if ((defined $pbparallel) && ($counter > 2 * $pbparallel));
|
|---|
| 3537 | $pm->start($counter) and next if (defined $pbparallel);
|
|---|
| 3538 |
|
|---|
| 3539 | # Get distro context
|
|---|
| 3540 | my $pbos = pb_distro_get_context($v);
|
|---|
| 3541 |
|
|---|
| 3542 | # Deal with date sync.
|
|---|
| 3543 | my $ntpline = pb_date2v($vtype,$pbos);
|
|---|
| 3544 |
|
|---|
| 3545 | # Name of the account to deal with for VM/VE/RM
|
|---|
| 3546 | # Do not use the one passed potentially with -a
|
|---|
| 3547 | my ($pbac) = pb_conf_get($vtype."login");
|
|---|
| 3548 | my $key = "";
|
|---|
| 3549 |
|
|---|
| 3550 | # Prepare the script to be executed on the VM/VE/RM
|
|---|
| 3551 | # in $ENV{'PBDESTDIR'}/setupv
|
|---|
| 3552 |
|
|---|
| 3553 | pb_log(2,"Preparing setup script for $v in $pbscript{$v}\n");
|
|---|
| 3554 | open(SCRIPT,"> $pbscript{$v}") || die "Unable to create $pbscript{$v}";
|
|---|
| 3555 |
|
|---|
| 3556 | print SCRIPT << 'EOF';
|
|---|
| 3557 | #!/usr/bin/perl -w
|
|---|
| 3558 |
|
|---|
| 3559 | use strict;
|
|---|
| 3560 | use File::Copy;
|
|---|
| 3561 |
|
|---|
| 3562 | # We should not need in this script more functions than what is provided
|
|---|
| 3563 | # by Base, Conf and Distribution to avoid problems at exec time.
|
|---|
| 3564 | # They are appended at the end.
|
|---|
| 3565 |
|
|---|
| 3566 | # Define mandatory global vars
|
|---|
| 3567 | EOF
|
|---|
| 3568 | my $ppref = "our";
|
|---|
| 3569 | $ppref = "my" if (($pbos->{'name'} =~ /^redhat/) && ($pbos->{'version'} =~ /^6/));
|
|---|
| 3570 | print SCRIPT << "EOF";
|
|---|
| 3571 | $ppref \$pbdebug = $pbdebug;
|
|---|
| 3572 | $ppref \$pbLOG;
|
|---|
| 3573 | $ppref \$pbsynmsg = "pbscript";
|
|---|
| 3574 | $ppref \$pbdisplaytype = "text";
|
|---|
| 3575 | $ppref \$pblocale = "";
|
|---|
| 3576 | EOF
|
|---|
| 3577 | print SCRIPT << 'EOF';
|
|---|
| 3578 | pb_log_init($pbdebug, $pbLOG);
|
|---|
| 3579 | EOF
|
|---|
| 3580 | print SCRIPT << "EOF";
|
|---|
| 3581 | \$Global::pb_stop_on_error = $Global::pb_stop_on_error;
|
|---|
| 3582 | pb_temp_init($pbkeep);
|
|---|
| 3583 | pb_conf_init("$ENV{'PBPROJ'}");
|
|---|
| 3584 |
|
|---|
| 3585 | EOF
|
|---|
| 3586 |
|
|---|
| 3587 | if ($vtype eq "ve") {
|
|---|
| 3588 | $vetype = pb_ve_get_type($vetype);
|
|---|
| 3589 | if ($vetype ne "docker") {
|
|---|
| 3590 | print SCRIPT << "EOF";
|
|---|
| 3591 | # For VE we first need to mount some FS
|
|---|
| 3592 | pb_system("mount -t proc /proc /proc") unless (-d "/proc/$$");
|
|---|
| 3593 | EOF
|
|---|
| 3594 | }
|
|---|
| 3595 | print SCRIPT << "EOF";
|
|---|
| 3596 | # For VE we need a good null dev
|
|---|
| 3597 | # Except for RedHat 6.2 where it's good and doesnt like being recreated
|
|---|
| 3598 | EOF
|
|---|
| 3599 | print SCRIPT "pb_system('rm -f /dev/null; mknod /dev/null c 1 3; chmod 777 /dev/null');\n" unless (($pbos->{'name'} =~ /^redhat/) && ($pbos->{'version'} =~ /^6/));
|
|---|
| 3600 | } elsif ($vtype =~ /(v|r)m/) {
|
|---|
| 3601 | # Nothing to do now.
|
|---|
| 3602 | my $useless = 0;
|
|---|
| 3603 | } else {
|
|---|
| 3604 | die "Unknown virtual type $vtype";
|
|---|
| 3605 | }
|
|---|
| 3606 |
|
|---|
| 3607 | print SCRIPT << 'EOF';
|
|---|
| 3608 |
|
|---|
| 3609 | # Adds $pbac->{$ENV{'PBPROJ'}} as an account if needed
|
|---|
| 3610 | #
|
|---|
| 3611 | my $file="/etc/passwd";
|
|---|
| 3612 | open(PBFILE,$file) || die "Unable to open $file";
|
|---|
| 3613 | my $found = 0;
|
|---|
| 3614 | while (<PBFILE>) {
|
|---|
| 3615 | EOF
|
|---|
| 3616 | print SCRIPT << "EOF";
|
|---|
| 3617 | \$found = 1 if (/^$pbac->{$ENV{'PBPROJ'}}:/);
|
|---|
| 3618 | EOF
|
|---|
| 3619 |
|
|---|
| 3620 | # TODO: use an external parameter
|
|---|
| 3621 | my $home = "/home";
|
|---|
| 3622 | # Solaris doesn't like that we use /home
|
|---|
| 3623 | $home = "/export/home" if ($pbos->{'type'} eq "pkg");
|
|---|
| 3624 |
|
|---|
| 3625 | print SCRIPT << "EOF";
|
|---|
| 3626 | }
|
|---|
| 3627 | close(PBFILE);
|
|---|
| 3628 |
|
|---|
| 3629 | if ( \$found == 0 ) {
|
|---|
| 3630 | if ( ! -d "$home" ) {
|
|---|
| 3631 | pb_mkdir_p("$home");
|
|---|
| 3632 | }
|
|---|
| 3633 | EOF
|
|---|
| 3634 | # TODO: Level of portability of these cmds ? Critical now for RM
|
|---|
| 3635 | # TODO: Check existence before adding to avoid errors
|
|---|
| 3636 | print SCRIPT << "EOF";
|
|---|
| 3637 | pb_system("/usr/sbin/groupadd $pbac->{$ENV{'PBPROJ'}}","Adding group $pbac->{$ENV{'PBPROJ'}}");
|
|---|
| 3638 | pb_system("/usr/sbin/useradd -g $pbac->{$ENV{'PBPROJ'}} -m -d $home/$pbac->{$ENV{'PBPROJ'}} $pbac->{$ENV{'PBPROJ'}}","Adding user $pbac->{$ENV{'PBPROJ'}} (group $pbac->{$ENV{'PBPROJ'}} - home $home/$pbac->{$ENV{'PBPROJ'}})");
|
|---|
| 3639 | }
|
|---|
| 3640 | EOF
|
|---|
| 3641 |
|
|---|
| 3642 | # Copy the content of our local conf file to the VM/VE/RM
|
|---|
| 3643 | my $content = pb_get_content(pb_distro_conffile());
|
|---|
| 3644 | print SCRIPT << "EOF";
|
|---|
| 3645 | #
|
|---|
| 3646 | # Create a temporary local conf file for distribution support
|
|---|
| 3647 | # This is created here before its use later. Its place is hardcoded, so no choice for the path
|
|---|
| 3648 | #
|
|---|
| 3649 | my \$tempconf = pb_distro_conffile();
|
|---|
| 3650 | pb_mkdir_p(dirname(\$tempconf));
|
|---|
| 3651 | open(CONF,"> \$tempconf") || die "Unable to create \$tempconf";
|
|---|
| 3652 | print CONF q{$content};
|
|---|
| 3653 | close(CONF);
|
|---|
| 3654 | EOF
|
|---|
| 3655 |
|
|---|
| 3656 | if ($vtype =~ /(v|r)m/) {
|
|---|
| 3657 | print SCRIPT << "EOF";
|
|---|
| 3658 | # allow ssh entry to build
|
|---|
| 3659 | #
|
|---|
| 3660 | mkdir "$home/$pbac->{$ENV{'PBPROJ'}}/.ssh",0700;
|
|---|
| 3661 | # Allow those accessing root to access the build account
|
|---|
| 3662 | copy("\$ENV{'HOME'}/.ssh/authorized_keys","$home/$pbac->{$ENV{'PBPROJ'}}/.ssh/authorized_keys");
|
|---|
| 3663 | chmod 0600,".ssh/authorized_keys";
|
|---|
| 3664 | pb_system("chown -R $pbac->{$ENV{'PBPROJ'}}:$pbac->{$ENV{'PBPROJ'}} $home/$pbac->{$ENV{'PBPROJ'}}","Finish setting up the account env for $pbac->{$ENV{'PBPROJ'}}");
|
|---|
| 3665 |
|
|---|
| 3666 | EOF
|
|---|
| 3667 | }
|
|---|
| 3668 | print SCRIPT << 'EOF';
|
|---|
| 3669 | # No passwd for build account only keys
|
|---|
| 3670 | $file="/etc/shadow";
|
|---|
| 3671 | if (-f $file) {
|
|---|
| 3672 | open(PBFILE,$file) || die "Unable to open $file";
|
|---|
| 3673 | open(PBOUT,"> $file.new") || die "Unable to open $file.new";
|
|---|
| 3674 | while (<PBFILE>) {
|
|---|
| 3675 | EOF
|
|---|
| 3676 | print SCRIPT << "EOF";
|
|---|
| 3677 | s/^$pbac->{$ENV{'PBPROJ'}}:\!\!:/$pbac->{$ENV{'PBPROJ'}}:*:/;
|
|---|
| 3678 | s/^$pbac->{$ENV{'PBPROJ'}}:\!:/$pbac->{$ENV{'PBPROJ'}}:*:/; #SLES 9 e.g.
|
|---|
| 3679 | s/^$pbac->{$ENV{'PBPROJ'}}:\\*LK\\*:/$pbac->{$ENV{'PBPROJ'}}:NP:/; #Solaris e.g.
|
|---|
| 3680 | EOF
|
|---|
| 3681 | print SCRIPT << 'EOF';
|
|---|
| 3682 | print PBOUT $_;
|
|---|
| 3683 | }
|
|---|
| 3684 | close(PBFILE);
|
|---|
| 3685 | close(PBOUT);
|
|---|
| 3686 | rename("$file.new",$file);
|
|---|
| 3687 | chmod 0640,$file;
|
|---|
| 3688 | }
|
|---|
| 3689 |
|
|---|
| 3690 | # TODO: systemd support
|
|---|
| 3691 | # Keep the VM in text mode
|
|---|
| 3692 | $file="/etc/inittab";
|
|---|
| 3693 | if (-f $file) {
|
|---|
| 3694 | open(PBFILE,$file) || die "Unable to open $file";
|
|---|
| 3695 | open(PBOUT,"> $file.new") || die "Unable to open $file.new";
|
|---|
| 3696 | while (<PBFILE>) {
|
|---|
| 3697 | s/^(..):5:initdefault:$/$1:3:initdefault:/;
|
|---|
| 3698 | print PBOUT $_;
|
|---|
| 3699 | }
|
|---|
| 3700 | close(PBFILE);
|
|---|
| 3701 | close(PBOUT);
|
|---|
| 3702 | rename("$file.new",$file);
|
|---|
| 3703 | chmod 0640,$file;
|
|---|
| 3704 | }
|
|---|
| 3705 |
|
|---|
| 3706 | # pb has to be added to portage group on gentoo
|
|---|
| 3707 |
|
|---|
| 3708 | # We need to have that pb_distro_get_context function
|
|---|
| 3709 | # Get it from Project-Builder::Distribution
|
|---|
| 3710 | # And we now need the conf file required for this to work created above
|
|---|
| 3711 |
|
|---|
| 3712 | my $pbos = pb_distro_get_context();
|
|---|
| 3713 | print "distro tuple: ".Dumper($pbos)."\n";
|
|---|
| 3714 |
|
|---|
| 3715 | # Adapt sudoers
|
|---|
| 3716 | # sudo is not default on Solaris and needs to be installed first
|
|---|
| 3717 | # from http://www.sunfreeware.com/programlistsparc10.html#sudo
|
|---|
| 3718 | if ($pbos->{'type'} eq "pkg") {
|
|---|
| 3719 | $file="/usr/local/etc/sudoers";
|
|---|
| 3720 | } else {
|
|---|
| 3721 | $file="/etc/sudoers";
|
|---|
| 3722 | }
|
|---|
| 3723 | open(PBFILE,$file) || die "Unable to open $file";
|
|---|
| 3724 | open(PBOUT,"> $file.new") || die "Unable to open $file.new";
|
|---|
| 3725 | while (<PBFILE>) {
|
|---|
| 3726 | EOF
|
|---|
| 3727 | # Skip what will be generated
|
|---|
| 3728 | print SCRIPT << "EOF";
|
|---|
| 3729 | next if (/^$pbac->{$ENV{'PBPROJ'}}\\s+/);
|
|---|
| 3730 | next if (/^Defaults:$pbac->{$ENV{'PBPROJ'}}\\s+/);
|
|---|
| 3731 | next if (/^Defaults:root\\s+\!requiretty/);
|
|---|
| 3732 | next if (/^Defaults:root\\s+env_keep/);
|
|---|
| 3733 | EOF
|
|---|
| 3734 | print SCRIPT << 'EOF';
|
|---|
| 3735 | s/Defaults\s+requiretty/# disable Defaults: requiretty/;
|
|---|
| 3736 | print PBOUT $_;
|
|---|
| 3737 | }
|
|---|
| 3738 | close(PBFILE);
|
|---|
| 3739 | EOF
|
|---|
| 3740 | print SCRIPT << "EOF";
|
|---|
| 3741 | # Some distro force requiretty at compile time, so disable here
|
|---|
| 3742 | print PBOUT "Defaults:$pbac->{$ENV{'PBPROJ'}} !requiretty\\n";
|
|---|
| 3743 | print PBOUT "Defaults:root !requiretty\\n";
|
|---|
| 3744 | EOF
|
|---|
| 3745 | # RH 6.2 sudo doesn't support env_keep
|
|---|
| 3746 | if (($pbos->{'name'} ne "redhat") && ($pbos->{'version'} ne "6.2")) {
|
|---|
| 3747 | print SCRIPT << "EOF";
|
|---|
| 3748 | # Keep proxy configuration while using sudo
|
|---|
| 3749 | print PBOUT "Defaults:$pbac->{$ENV{'PBPROJ'}} env_keep += \\\"http_proxy ftp_proxy\\\"\\n";
|
|---|
| 3750 | print PBOUT "Defaults:root env_keep += \\\"http_proxy ftp_proxy\\\"\\n";
|
|---|
| 3751 | EOF
|
|---|
| 3752 | }
|
|---|
| 3753 | # Try to restrict security to what is really needed
|
|---|
| 3754 | if ($vtype =~ /^vm/) {
|
|---|
| 3755 | my $hpath = pb_distro_get_param($pbos,pb_conf_get("ospathcmd-halt"));
|
|---|
| 3756 | my @sudocmds = pb_get_sudocmds($pbos,$ntpline,"sudo $hpath","sudo /bin/date");
|
|---|
| 3757 | print SCRIPT << "EOF";
|
|---|
| 3758 | # This is needed in order to be able on VM to halt the machine from the $pbac->{$ENV{'PBPROJ'}} account at least
|
|---|
| 3759 | # Build account $pbac->{$ENV{'PBPROJ'}} in VM also needs to setup date and install deps.
|
|---|
| 3760 | # Nothing else should be needed
|
|---|
| 3761 | EOF
|
|---|
| 3762 | foreach my $c (@sudocmds) {
|
|---|
| 3763 | print SCRIPT "print PBOUT \"$pbac->{$ENV{'PBPROJ'}} ALL = NOPASSWD: $c\\n\";\n";
|
|---|
| 3764 | }
|
|---|
| 3765 | } elsif ($vtype =~ /^rm/) {
|
|---|
| 3766 | my @sudocmds = pb_get_sudocmds($pbos,$ntpline);
|
|---|
| 3767 | print SCRIPT << "EOF";
|
|---|
| 3768 | # Build account $pbac->{$ENV{'PBPROJ'}} in RM only needs to setup date and install deps if needed each time
|
|---|
| 3769 | EOF
|
|---|
| 3770 | foreach my $c (@sudocmds) {
|
|---|
| 3771 | print SCRIPT "print PBOUT \"$pbac->{$ENV{'PBPROJ'}} ALL = NOPASSWD: $c\\n\";\n";
|
|---|
| 3772 | }
|
|---|
| 3773 | } else {
|
|---|
| 3774 | print SCRIPT << "EOF";
|
|---|
| 3775 | # Build account $pbac->{$ENV{'PBPROJ'}} for VE needs to do a lot in the host (and chroot), so allow without restriction for now
|
|---|
| 3776 | print PBOUT "$pbac->{$ENV{'PBPROJ'}} ALL=(ALL) NOPASSWD:ALL\n";
|
|---|
| 3777 | EOF
|
|---|
| 3778 | }
|
|---|
| 3779 | my $sudomode = pb_distro_get_param($pbos,pb_conf_get("ossudoersmode"));
|
|---|
| 3780 | print SCRIPT << 'EOF';
|
|---|
| 3781 | close(PBOUT);
|
|---|
| 3782 | rename("$file.new",$file);
|
|---|
| 3783 | EOF
|
|---|
| 3784 | print SCRIPT << "EOF";
|
|---|
| 3785 | chmod 0$sudomode,\$file;
|
|---|
| 3786 |
|
|---|
| 3787 | EOF
|
|---|
| 3788 |
|
|---|
| 3789 | if ($vtype =~ /(v|r)m/) {
|
|---|
| 3790 | # Sync date
|
|---|
| 3791 | # do it after sudoers is setup
|
|---|
| 3792 | print SCRIPT "my \$res = pb_system(\"$ntpline\",\"Updating time with $ntpline\",\"mayfailverbose\");\n";
|
|---|
| 3793 | print SCRIPT "if (\$res != 0) {\n";
|
|---|
| 3794 | # try again with another method
|
|---|
| 3795 | $ntpline = pb_date2v($vtype,$pbos,1);
|
|---|
| 3796 | print SCRIPT " pb_system(\"$ntpline\",\"Updating time with $ntpline\",\"mayfailverbose\");\n";
|
|---|
| 3797 | print SCRIPT "}\n";
|
|---|
| 3798 | }
|
|---|
| 3799 |
|
|---|
| 3800 | print SCRIPT << 'EOF';
|
|---|
| 3801 |
|
|---|
| 3802 | # We may need a proxy configuration. Get it from the local env
|
|---|
| 3803 | pb_apply_conf_proxy($pbos);
|
|---|
| 3804 |
|
|---|
| 3805 | # First install all required packages
|
|---|
| 3806 | pb_system("dnf clean all","Cleaning dnf env","mayfail") if (($pbos->{'name'} eq "fedora") && ($pbos->{'version'} >= 22));
|
|---|
| 3807 | pb_system("yum clean all","Cleaning yum env","mayfail") if ((($pbos->{'name'} eq "fedora") && ($pbos->{'version'} < 22)) || ($pbos->{'name'} eq "asianux") || ($pbos->{'name'} eq "rhel"));
|
|---|
| 3808 | my ($ospkgdep) = pb_conf_get_if("ospkgdep");
|
|---|
| 3809 |
|
|---|
| 3810 | my $pkgdep = pb_distro_get_param($pbos,$ospkgdep);
|
|---|
| 3811 | pb_distro_installdeps(undef,$pbos,pb_distro_only_deps_needed($pbos,join(' ',split(/,/,$pkgdep))));
|
|---|
| 3812 |
|
|---|
| 3813 | EOF
|
|---|
| 3814 | my $itype = pb_distro_get_param($pbos,pb_conf_get("pbinstalltype"));
|
|---|
| 3815 | # Install from sandbox mean a file base install
|
|---|
| 3816 | $itype = "file" if (defined $sbx);
|
|---|
| 3817 | if ($itype =~ /^file/) {
|
|---|
| 3818 | my $cmdget;
|
|---|
| 3819 | if (defined $sbx) {
|
|---|
| 3820 | # Install from sandbox mean using the result of the just passed sbx2build command
|
|---|
| 3821 | # Get content saved in cms2build
|
|---|
| 3822 | my ($pkg) = pb_conf_read("$ENV{'PBDESTDIR'}/$ENV{'PBPROJVER'}-$ENV{'PBPROJTAG'}.pb","pbpkg");
|
|---|
| 3823 | my $pbextdir = pb_get_extdir();
|
|---|
| 3824 | die "Unable to get package list" if (not defined $pkg);
|
|---|
| 3825 |
|
|---|
| 3826 | # We consider 2 specific packages
|
|---|
| 3827 | my $vertag1 = $pkg->{"ProjectBuilder"};
|
|---|
| 3828 | my $vertag2 = $pkg->{"project-builder"};
|
|---|
| 3829 | # get the version of the current package - maybe different
|
|---|
| 3830 | pb_log(2,"Vertag1: $vertag1\n");
|
|---|
| 3831 | pb_log(2,"Vertag2: $vertag2\n");
|
|---|
| 3832 | my ($pbver1,$tmp1) = split(/-/,$vertag1);
|
|---|
| 3833 | my ($pbver2,$tmp2) = split(/-/,$vertag2);
|
|---|
| 3834 | $cmdget = "mv /tmp/ProjectBuilder-$pbver1$pbextdir.tar.gz ProjectBuilder-latest.tar.gz ; mv /tmp/project-builder-$pbver2$pbextdir.tar.gz project-builder-latest.tar.gz";
|
|---|
| 3835 | } else {
|
|---|
| 3836 | # TODO: shouldn't we have a variable to specify the source file?
|
|---|
| 3837 | # And shouldn't we be getting the one that matches the current pb version?
|
|---|
| 3838 | # For the moment, just take the latest stable one
|
|---|
| 3839 | my $wget = pb_check_req("wget",0);
|
|---|
| 3840 | $cmdget = "$wget --passive-ftp ftp://ftp.project-builder.org/src/ProjectBuilder-latest.tar.gz; $wget --passive-ftp ftp://ftp.project-builder.org/src/project-builder-latest.tar.gz";
|
|---|
| 3841 | }
|
|---|
| 3842 | print SCRIPT << 'EOF';
|
|---|
| 3843 | # Then install manually the missing perl modules
|
|---|
| 3844 | my ($osperldep,$osperlver) = pb_conf_get_if("osperldep","osperlver");
|
|---|
| 3845 |
|
|---|
| 3846 | my $perldep = pb_distro_get_param($pbos,$osperldep);
|
|---|
| 3847 | my $bashopt = "";
|
|---|
| 3848 | $bashopt = "-x" if ($pbdebug ge 1);
|
|---|
| 3849 | my $verbopt = "mayfail";
|
|---|
| 3850 | $verbopt = "mayfailverbose" if ($pbdebug ge 1);
|
|---|
| 3851 | foreach my $m (split(/,/,$perldep)) {
|
|---|
| 3852 | # Skip empty deps
|
|---|
| 3853 | next if ($m =~ /^\s*$/);
|
|---|
| 3854 | my $dir = $m;
|
|---|
| 3855 | $dir =~ s/-.*//;
|
|---|
| 3856 | pb_system("echo \"rm -rf $m* ; wget http://search.cpan.org/CPAN/modules/by-module/$dir/$m-$osperlver->{$m}.tar.gz ; gzip -cd $m-$osperlver->{$m}.tar.gz | tar xf - ; cd $m* ; if [ -f Build.PL ]; then perl Build.PL; ./Build ; ./Build install ; else perl Makefile.PL; make ; make install ; fi; cd .. ; rm -rf $m*\" | bash -e $bashopt" ,"Installing perl module $m-$osperlver->{$m}",$verbopt);
|
|---|
| 3857 | }
|
|---|
| 3858 | EOF
|
|---|
| 3859 | print SCRIPT << 'EOF';
|
|---|
| 3860 | pb_system("rm -rf ProjectBuilder-* ; rm -rf project-builder-* ; rm -rf `perl -V:installvendorlib | awk -F\"'\" '{print \$2}'`/ProjectBuilder ;
|
|---|
| 3861 | EOF
|
|---|
| 3862 | print SCRIPT " $cmdget ; ";
|
|---|
| 3863 | print SCRIPT << 'EOF'
|
|---|
| 3864 | gzip -cd ProjectBuilder-latest.tar.gz | tar xf - ; cd ProjectBuilder-* ; perl Makefile.PL ; make ; make install ; cd .. ; rm -rf ProjectBuilder-* ; gzip -cd project-builder-latest.tar.gz | tar xf - ; cd project-builder-* ; perl Makefile.PL ; make ; make install ; cd .. ; rm -rf project-builder-* ;","Building Project-Builder");
|
|---|
| 3865 | EOF
|
|---|
| 3866 | } elsif ($itype =~ /^pkg/) {
|
|---|
| 3867 | # pkg based install. We need to point to the project-builder.org repository
|
|---|
| 3868 | print SCRIPT << 'EOF';
|
|---|
| 3869 | my $pkgforpb = pb_distro_get_param($pbos,pb_conf_get_if("ospkg"));
|
|---|
| 3870 | pb_distro_setuposrepo($pbos);
|
|---|
| 3871 | pb_distro_installdeps(undef,$pbos,pb_distro_only_deps_needed($pbos,join(' ',split(/,/,$pkgforpb))));
|
|---|
| 3872 | EOF
|
|---|
| 3873 | } else {
|
|---|
| 3874 | # Unknown install type
|
|---|
| 3875 | die("Unknown install type $itype->{$ENV{'PBPROJ'}} for param pbinstalltype");
|
|---|
| 3876 | }
|
|---|
| 3877 | print SCRIPT << 'EOF';
|
|---|
| 3878 | pb_system("pbdistrocheck",undef,"verbose");
|
|---|
| 3879 | pb_system("pb -h",undef,"verbose");
|
|---|
| 3880 | EOF
|
|---|
| 3881 | if ($vtype eq "ve"){
|
|---|
| 3882 | if ($vetype ne "docker") {
|
|---|
| 3883 | print SCRIPT << 'EOF';
|
|---|
| 3884 | # For VE we need to umount some FS at the end
|
|---|
| 3885 |
|
|---|
| 3886 | pb_system("umount /proc","Unmounting /proc","mayfail");
|
|---|
| 3887 | EOF
|
|---|
| 3888 | }
|
|---|
| 3889 | print SCRIPT << 'EOF';
|
|---|
| 3890 | # Create a basic network file if not already there
|
|---|
| 3891 |
|
|---|
| 3892 | my $nf="/etc/sysconfig/network";
|
|---|
| 3893 | if ((! -f $nf) && ($pbos->{'type'} eq "rpm") && ($pbos->{'family'} ne "novell")) {
|
|---|
| 3894 | open(NF,"> $nf") || die "Unable to create $nf";
|
|---|
| 3895 | print NF "NETWORKING=yes\n";
|
|---|
| 3896 | print NF "HOSTNAME=localhost\n";
|
|---|
| 3897 | close(NF);
|
|---|
| 3898 | }
|
|---|
| 3899 | chmod 0755,$nf;
|
|---|
| 3900 | EOF
|
|---|
| 3901 | }
|
|---|
| 3902 |
|
|---|
| 3903 | # Adds pb_distro_get_context and all functions needed from ProjectBuilder::Distribution, Conf and Base
|
|---|
| 3904 | foreach my $m ("ProjectBuilder/Base.pm","ProjectBuilder/Distribution.pm","ProjectBuilder/Conf.pm") {
|
|---|
| 3905 | foreach my $d (@INC) {
|
|---|
| 3906 | my $f = "$d/$m";
|
|---|
| 3907 | if (-f "$f") {
|
|---|
| 3908 | open(PBD,"$f") || die "Unable to open $f: $!";
|
|---|
| 3909 | while (<PBD>) {
|
|---|
| 3910 | next if (/^package/);
|
|---|
| 3911 | next if (/^use Exporter/);
|
|---|
| 3912 | next if (/^use ProjectBuilder::/);
|
|---|
| 3913 | next if (/^our /);
|
|---|
| 3914 | print SCRIPT $_;
|
|---|
| 3915 | }
|
|---|
| 3916 | close(PBD);
|
|---|
| 3917 | # We just need the first one of each file wrt @INC - hopefully that's the right one.
|
|---|
| 3918 | last;
|
|---|
| 3919 | }
|
|---|
| 3920 | }
|
|---|
| 3921 | }
|
|---|
| 3922 | # Use a fake pb_version_init version here
|
|---|
| 3923 | print SCRIPT << "EOF";
|
|---|
| 3924 | sub pb_version_init {
|
|---|
| 3925 |
|
|---|
| 3926 | return("$projectbuilderver","$projectbuilderrev");
|
|---|
| 3927 | }
|
|---|
| 3928 | 1;
|
|---|
| 3929 | EOF
|
|---|
| 3930 | close(SCRIPT);
|
|---|
| 3931 | chmod 0755,"$pbscript{$v}";
|
|---|
| 3932 |
|
|---|
| 3933 | $pm->finish if (defined $pbparallel);
|
|---|
| 3934 | }
|
|---|
| 3935 | $pm->wait_all_children if (defined $pbparallel);
|
|---|
| 3936 | die "Aborting, one or more of the children failed." if ((not $all_ok) && ($Global::pb_stop_on_error));
|
|---|
| 3937 |
|
|---|
| 3938 | # These build scripts need to be run as root and force stop of VM at end
|
|---|
| 3939 | $ENV{'PBACCOUNT'} = "root";
|
|---|
| 3940 |
|
|---|
| 3941 | $sbx = "" if (not defined $sbx);
|
|---|
| 3942 | # Launch the VM/VE/RM
|
|---|
| 3943 | pb_log(2,"DEBUG: before parallel launch, pbscript hash is:".Dumper(%pbscript)."\n");
|
|---|
| 3944 | pb_parallel_launchv(\%pbscript,$vtype,uc($vtype)."Script".$sbx,$pbstep,$pbimage,$pbforce,0,$pbsnap);
|
|---|
| 3945 |
|
|---|
| 3946 | return;
|
|---|
| 3947 | }
|
|---|
| 3948 |
|
|---|
| 3949 | # Function to create a snapshot named 'pb' for VMs and a compressed tar for VEs
|
|---|
| 3950 | sub pb_snap2v {
|
|---|
| 3951 |
|
|---|
| 3952 | my $vtype = shift;
|
|---|
| 3953 | my $pbstep = 2;
|
|---|
| 3954 |
|
|---|
| 3955 | my ($vm,$all) = pb_get2v($vtype);
|
|---|
| 3956 |
|
|---|
| 3957 | # Script generated
|
|---|
| 3958 | my $pbscript = "$ENV{'PBDESTDIR'}/snapv.$$";
|
|---|
| 3959 |
|
|---|
| 3960 | my ($pbac) = pb_conf_get($vtype."login");
|
|---|
| 3961 |
|
|---|
| 3962 | foreach my $v (@$vm) {
|
|---|
| 3963 | if ($vtype eq "ve") {
|
|---|
| 3964 | # Get distro context
|
|---|
| 3965 | my $pbos = pb_distro_get_context($v);
|
|---|
| 3966 | my ($vepath) = pb_conf_get("vepath");
|
|---|
| 3967 |
|
|---|
| 3968 | # Test if an existing snapshot exists and remove it if there is a VE
|
|---|
| 3969 | if ((-f "$vepath->{$ENV{'PBPROJ'}}/$pbos->{'name'}-$pbos->{'version'}-$pbos->{'arch'}.tar.gz") &&
|
|---|
| 3970 | (! -d "$vepath->{$ENV{'PBPROJ'}}/$pbos->{'name'}/$pbos->{'version'}/$pbos->{'arch'}")) {
|
|---|
| 3971 | pb_system("sudo rm -f $vepath->{$ENV{'PBPROJ'}}/$pbos->{'name'}-$pbos->{'version'}-$pbos->{'arch'}.tar.gz","Removing previous snapshot $pbos->{'name'}-$pbos->{'version'}-$pbos->{'arch'}.tar.gz");
|
|---|
| 3972 | }
|
|---|
| 3973 | }
|
|---|
| 3974 |
|
|---|
| 3975 | # Prepare the script to be executed on the VM/VE
|
|---|
| 3976 | open(SCRIPT,"> $pbscript") || die "Unable to create $pbscript";
|
|---|
| 3977 | print SCRIPT << 'EOF';
|
|---|
| 3978 | #!/bin/bash
|
|---|
| 3979 | sleep 2
|
|---|
| 3980 | EOF
|
|---|
| 3981 | close(SCRIPT);
|
|---|
| 3982 | chmod 0755,"$pbscript";
|
|---|
| 3983 |
|
|---|
| 3984 | # Force shutdown of VM/VE
|
|---|
| 3985 | # Force snapshot of VM/VE
|
|---|
| 3986 | pb_script2v($pbscript,$vtype,$pbstep,1,$v,1);
|
|---|
| 3987 | }
|
|---|
| 3988 | return;
|
|---|
| 3989 | }
|
|---|
| 3990 |
|
|---|
| 3991 | # Function to update VMs/VEs/RMs with the latest distribution content
|
|---|
| 3992 | sub pb_update2v {
|
|---|
| 3993 |
|
|---|
| 3994 | my $vtype = shift;
|
|---|
| 3995 | my $pbstep = 2;
|
|---|
| 3996 |
|
|---|
| 3997 | my ($vm,$all) = pb_get2v($vtype);
|
|---|
| 3998 |
|
|---|
| 3999 | # Script generated
|
|---|
| 4000 | my $pbscript = "$ENV{'PBDESTDIR'}/updatev.$$";
|
|---|
| 4001 |
|
|---|
| 4002 | my ($pbac) = pb_conf_get($vtype."login");
|
|---|
| 4003 |
|
|---|
| 4004 | foreach my $v (@$vm) {
|
|---|
| 4005 | # Get distro context
|
|---|
| 4006 | my $pbos = pb_distro_get_context($v);
|
|---|
| 4007 |
|
|---|
| 4008 | # Prepare the script to be executed on the VM/VE/RM
|
|---|
| 4009 | # in $ENV{'PBDESTDIR'}/updatev
|
|---|
| 4010 | open(SCRIPT,"> $pbscript") || die "Unable to create $pbscript";
|
|---|
| 4011 |
|
|---|
| 4012 | print SCRIPT << 'EOF';
|
|---|
| 4013 | #!/bin/bash
|
|---|
| 4014 | sleep 2
|
|---|
| 4015 | EOF
|
|---|
| 4016 | # VE needs a good /proc
|
|---|
| 4017 | $vetype = pb_ve_get_type($vetype);
|
|---|
| 4018 | if (($vtype eq "ve") && ($vetype ne "docker")) {
|
|---|
| 4019 | print SCRIPT "sudo /bin/mount -t proc /proc /proc\n";
|
|---|
| 4020 | }
|
|---|
| 4021 | print SCRIPT "$pbos->{'update'}\n";
|
|---|
| 4022 | if (($vtype eq "ve") && ($vetype ne "docker")) {
|
|---|
| 4023 | print SCRIPT "sudo /bin/umount /proc\n";
|
|---|
| 4024 | }
|
|---|
| 4025 | close(SCRIPT);
|
|---|
| 4026 | chmod 0755,"$pbscript";
|
|---|
| 4027 |
|
|---|
| 4028 | # Force shutdown of VM except
|
|---|
| 4029 | pb_script2v($pbscript,$vtype,$pbstep,1,$v);
|
|---|
| 4030 | }
|
|---|
| 4031 | return;
|
|---|
| 4032 | }
|
|---|
| 4033 |
|
|---|
| 4034 | sub pb_announce {
|
|---|
| 4035 |
|
|---|
| 4036 | my $antype = shift;
|
|---|
| 4037 |
|
|---|
| 4038 | # Get all required parameters
|
|---|
| 4039 | my ($pbpackager,$pbrepo) = pb_conf_get("pbpackager","pbrepo");
|
|---|
| 4040 | my ($pkgv, $pkgt, $testver) = pb_conf_get_if("pkgver","pkgtag","testver");
|
|---|
| 4041 | if (((not defined $testver) || (not defined $testver->{$ENV{'PBPROJ'}}) || ($testver->{$ENV{'PBPROJ'}} !~ /true/i)) && ($antype eq "Clean")) {
|
|---|
| 4042 | # We just clean for test versions
|
|---|
| 4043 | pb_log(0,"Unable to clean SSH repository for non testver version\n");
|
|---|
| 4044 | return;
|
|---|
| 4045 | }
|
|---|
| 4046 | my $pkg = pb_cms_get_pkg($defpkgdir,$extpkgdir);
|
|---|
| 4047 | my @pkgs = @$pkg;
|
|---|
| 4048 | my %pkgs;
|
|---|
| 4049 | my $first = 0;
|
|---|
| 4050 |
|
|---|
| 4051 | # Get all distros concerned
|
|---|
| 4052 | my $pbos = pb_distro_get_context();
|
|---|
| 4053 | my $distrolist = pb_get_distros($pbos,undef);
|
|---|
| 4054 | my %dl;
|
|---|
| 4055 | my %theorlist;
|
|---|
| 4056 | my %archlist;
|
|---|
| 4057 | foreach my $d (split(/,/,$distrolist)) {
|
|---|
| 4058 | my ($d1,$d2,$d3) = split(/-/,$d);
|
|---|
| 4059 | $dl{$d1}++;
|
|---|
| 4060 | }
|
|---|
| 4061 |
|
|---|
| 4062 | # Command to find packages on repo
|
|---|
| 4063 | my $findstr = "find ".join(" ",keys %dl)." ";
|
|---|
| 4064 | my $srcstr = "";
|
|---|
| 4065 | # Generated announce files
|
|---|
| 4066 | my @files;
|
|---|
| 4067 |
|
|---|
| 4068 | foreach my $pbpkg (@pkgs) {
|
|---|
| 4069 | if ($first != 0) {
|
|---|
| 4070 | $findstr .= "-o ";
|
|---|
| 4071 | }
|
|---|
| 4072 | $first++;
|
|---|
| 4073 | if ((defined $pkgv) && (defined $pkgv->{$pbpkg})) {
|
|---|
| 4074 | $pbver = $pkgv->{$pbpkg};
|
|---|
| 4075 | } else {
|
|---|
| 4076 | $pbver = $ENV{'PBPROJVER'};
|
|---|
| 4077 | }
|
|---|
| 4078 | if ((defined $pkgt) && (defined $pkgt->{$pbpkg})) {
|
|---|
| 4079 | $pbtag = $pkgt->{$pbpkg};
|
|---|
| 4080 | } else {
|
|---|
| 4081 | $pbtag = $ENV{'PBPROJTAG'};
|
|---|
| 4082 | }
|
|---|
| 4083 |
|
|---|
| 4084 | # TODO: use virtual/real names here now
|
|---|
| 4085 | my $pbrealpkg = $pbpkg;
|
|---|
| 4086 | my $pbrealpkgrpm = pb_cms_get_real_pkg($pbpkg,"rpm");
|
|---|
| 4087 | my $pbrealpkgdeb = pb_cms_get_real_pkg($pbpkg,"deb");
|
|---|
| 4088 | if ($antype eq "Clean") {
|
|---|
| 4089 | # We only clean test versions anyway
|
|---|
| 4090 | $pbtag = "0";
|
|---|
| 4091 | my $nver = $pbver;
|
|---|
| 4092 | my $ntag = "[2-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9]";
|
|---|
| 4093 | $pbver .= $ntag;
|
|---|
| 4094 | $findstr .= "-name \'$pbrealpkgrpm-$pbver-$pbtag\.*.rpm\' -o -name \'$pbrealpkgrpm-debug-$pbver-$pbtag\.*.rpm\' -o -name \'$pbrealpkgdeb"."_$pbver-$pbtag"."_*\.deb\' -o -name \'$pbrealpkgdeb"."_$pbver-$pbtag.dsc\' -o -name \'$pbrealpkgdeb"."_$pbver-$pbtag.tar.gz\' -o -name \'$pbrealpkg-$nver"."_p$ntag\.ebuild\' -o -name \'$pbrealpkg-$pbver-$pbtag*\.pkg\.gz\' -o -name \'$pbrealpkg-$pbver-$pbtag*\.sd\' ";
|
|---|
| 4095 | $srcstr .= "src/$pbrealpkg-$pbver.tar.gz src/$pbrealpkg-$pbver.pbconf.tar.gz ";
|
|---|
| 4096 | } else {
|
|---|
| 4097 | # "Announce" and "Check"
|
|---|
| 4098 | my @date=pb_get_date();
|
|---|
| 4099 | # the matching is only done on packages made the same day for test version. Hopefully this is enough
|
|---|
| 4100 | my $nver;
|
|---|
| 4101 | if ((defined $testver) && (defined $testver->{$ENV{'PBPROJ'}}) && ($testver->{$ENV{'PBPROJ'}} =~ /true/i)) {
|
|---|
| 4102 | $pbtag = "0";
|
|---|
| 4103 | my $ntag .= strftime("%Y%m%d*", @date);
|
|---|
| 4104 | $nver = $pbver."_p$ntag*";
|
|---|
| 4105 | $pbver .= "$ntag*";
|
|---|
| 4106 | } else {
|
|---|
| 4107 | $nver = $pbver."-r$pbtag";
|
|---|
| 4108 | }
|
|---|
| 4109 | $findstr .= "-name \'$pbrealpkgrpm-$pbver-$pbtag\.*.rpm\' -o -name \'$pbrealpkgdeb"."_$pbver-$pbtag"."_*\.deb\' -o -name \'$pbrealpkg-$nver\.ebuild\' -o -name \'$pbrealpkg-$pbver\.pkg\.gz\' -o -name \'$pbrealpkg-$pbver\.sd\' ";
|
|---|
| 4110 | }
|
|---|
| 4111 |
|
|---|
| 4112 | if ($antype eq "Announce") {
|
|---|
| 4113 | my $chglog;
|
|---|
| 4114 |
|
|---|
| 4115 | pb_cms_init($pbinit);
|
|---|
| 4116 | # Get project info on log file and generate tmp files used later on
|
|---|
| 4117 | $chglog = "$ENV{'PBROOTDIR'}/$pbpkg/pbcl";
|
|---|
| 4118 | $chglog = "$ENV{'PBROOTDIR'}/pbcl" if (! -f $chglog);
|
|---|
| 4119 | $chglog = undef if (! -f $chglog);
|
|---|
| 4120 |
|
|---|
| 4121 | open(OUT,"> $ENV{'PBTMP'}/$pbpkg.ann") || die "Unable to create $ENV{'PBTMP'}/$pbpkg.ann: $!";
|
|---|
| 4122 | my $pb;
|
|---|
| 4123 | $pb->{'realpkg'} = $pbrealpkg;
|
|---|
| 4124 | $pb->{'ver'} = $pbver;
|
|---|
| 4125 | $pb->{'tag'} = $pbtag;
|
|---|
| 4126 | $pb->{'date'} = $pbdate;
|
|---|
| 4127 | $pb->{'extdir'} = pb_get_extdir();
|
|---|
| 4128 | $pb->{'chglog'} = $chglog;
|
|---|
| 4129 | $pb->{'packager'} = $pbpackager;
|
|---|
| 4130 | $pb->{'proj'} = $ENV{'PBPROJ'};
|
|---|
| 4131 | $pb->{'repo'} = $pbrepo;
|
|---|
| 4132 | $pb->{'pbos'}->{'type'} = "announce";
|
|---|
| 4133 | $pb->{'pbos'}->{'suffix'} = "none";
|
|---|
| 4134 | pb_changelog($pb,\*OUT,"yes");
|
|---|
| 4135 | close(OUT);
|
|---|
| 4136 | push(@files,"$ENV{'PBTMP'}/$pbpkg.ann");
|
|---|
| 4137 | } elsif ($antype eq "Check") {
|
|---|
| 4138 | # For the check we also build the theoritical complete list we should get
|
|---|
| 4139 | foreach my $d (split(/,/,$distrolist)) {
|
|---|
| 4140 | $pbos = pb_distro_get_context($d);
|
|---|
| 4141 | if ($pbos->{'type'} eq "rpm") {
|
|---|
| 4142 | $theorlist{"$pbos->{'name'}/$pbos->{'version'}/$pbos->{'arch'}/$pbrealpkgrpm-$pbver-$pbtag$pbos->{'suffix'}"} = 0;
|
|---|
| 4143 | } elsif ($pbos->{'type'} eq "deb") {
|
|---|
| 4144 | $theorlist{"$pbos->{'name'}/$pbos->{'version'}/$pbrealpkgdeb"."_$pbver-$pbtag"} = 0;
|
|---|
| 4145 | # TODO are we always using the last arch ?
|
|---|
| 4146 | $archlist{"$pbos->{'name'}/$pbos->{'version'}/$pbrealpkgdeb"."_$pbver-$pbtag"} = "$pbos->{'arch'}";
|
|---|
| 4147 | } elsif ($pbos->{'type'} eq "ebuild") {
|
|---|
| 4148 | my $prefix = "-r";
|
|---|
| 4149 | $prefix = "_p" if ((defined $testver) && (defined $testver->{$ENV{'PBPROJ'}}) && ($testver->{$ENV{'PBPROJ'}} =~ /true/i));
|
|---|
| 4150 | $theorlist{"$pbos->{'name'}/$pbos->{'version'}/$pbrealpkg-$pbver$prefix$pbtag.ebuild"} = 0;
|
|---|
| 4151 | $archlist{"$pbos->{'name'}/$pbos->{'version'}/$pbrealpkg-$pbver$prefix$pbtag.ebuild"} = "$pbos->{'arch'}";
|
|---|
| 4152 | } elsif ($pbos->{'type'} eq "pkg") {
|
|---|
| 4153 | $theorlist{"$pbos->{'name'}/$pbos->{'version'}/$pbos->{'arch'}/$pbrealpkg-$pbver-$pbtag.pkg.gz"} = 0;
|
|---|
| 4154 | } else {
|
|---|
| 4155 | pb_log(1,"No theoritical list possible for type $pbos->{'type'}\n");
|
|---|
| 4156 | }
|
|---|
| 4157 | }
|
|---|
| 4158 | }
|
|---|
| 4159 | pb_log(2,"theorlist initial: ".Dumper(%theorlist)."\n");
|
|---|
| 4160 | pb_log(2,"archlist: ".Dumper(%archlist)."\n");
|
|---|
| 4161 | }
|
|---|
| 4162 | if ($antype eq "Announce") {
|
|---|
| 4163 | $findstr .= " | grep -Ev \'src.rpm\'";
|
|---|
| 4164 | } elsif ($antype eq "Clean") {
|
|---|
| 4165 | $findstr .= " | xargs rm -f -v $srcstr ";
|
|---|
| 4166 | }
|
|---|
| 4167 |
|
|---|
| 4168 | # Prepare the command to run and execute it
|
|---|
| 4169 | open(PBS,"> $ENV{'PBTMP'}/pbscript") || die "Unable to create $ENV{'PBTMP'}/pbscript";
|
|---|
| 4170 | print PBS "#!/bin/bash\n";
|
|---|
| 4171 | print PBS "set -x\n" if ($pbdebug gt 1);
|
|---|
| 4172 | print PBS "$findstr | sort 2> /dev/null\n";
|
|---|
| 4173 | close(PBS);
|
|---|
| 4174 | chmod 0755,"$ENV{'PBTMP'}/pbscript";
|
|---|
| 4175 | pb_send2target("Announce","$ENV{'PBTMP'}/pbscript");
|
|---|
| 4176 |
|
|---|
| 4177 | my $sl = "Project $ENV{'PBPROJ'} version $ENV{'PBPROJVER'} is now available";
|
|---|
| 4178 | if ($antype eq "Announce") {
|
|---|
| 4179 | # Get subject line
|
|---|
| 4180 | pb_log(0,"Please enter the title of your announce\n");
|
|---|
| 4181 | pb_log(0,"(By default: $sl)\n");
|
|---|
| 4182 | my $sl2 = <STDIN>;
|
|---|
| 4183 | $sl = $sl2 if ($sl2 !~ /^$/);
|
|---|
| 4184 |
|
|---|
| 4185 | # Prepare a template of announce
|
|---|
| 4186 | open(ANN,"> $ENV{'PBTMP'}/announce.html") || die "Unable to create $ENV{'PBTMP'}/announce.html: $!";
|
|---|
| 4187 | print ANN << "EOF";
|
|---|
| 4188 | $sl</p>
|
|---|
| 4189 |
|
|---|
| 4190 | <p>The project team is happy to announce the availability of a newest version of $ENV{'PBPROJ'} $ENV{'PBPROJVER'}. Enjoy it as usual!</p>
|
|---|
| 4191 | <p>
|
|---|
| 4192 | Now available at <a href="$pbrepo->{$ENV{'PBPROJ'}}">$pbrepo->{$ENV{'PBPROJ'}}</a>
|
|---|
| 4193 | </p>
|
|---|
| 4194 | <p>
|
|---|
| 4195 | EOF
|
|---|
| 4196 | }
|
|---|
| 4197 |
|
|---|
| 4198 | open(LOG,"$ENV{'PBTMP'}/system.$$.log") || die "Unable to read $ENV{'PBTMP'}/system.$$.log: $!";
|
|---|
| 4199 | if ($antype eq "Announce") {
|
|---|
| 4200 | my $col = 2;
|
|---|
| 4201 | my $i = 1;
|
|---|
| 4202 | print ANN << 'EOF';
|
|---|
| 4203 | <TABLE WIDTH="100%" CELLPADDING="0" CELLSPACING="0" BORDER="0">
|
|---|
| 4204 | <TR>
|
|---|
| 4205 | EOF
|
|---|
| 4206 | while (<LOG>) {
|
|---|
| 4207 | print ANN "<TD><A HREF=\"$pbrepo->{$ENV{'PBPROJ'}}/$_\">$_</A></TD>";
|
|---|
| 4208 | $i++;
|
|---|
| 4209 | if ($i > $col) {
|
|---|
| 4210 | print ANN "</TR>\n<TR>";
|
|---|
| 4211 | $i = 1;
|
|---|
| 4212 | }
|
|---|
| 4213 | }
|
|---|
| 4214 | } elsif ($antype eq "Clean") {
|
|---|
| 4215 | while (<LOG>) {
|
|---|
| 4216 | # skip errors
|
|---|
| 4217 | next if ($_ !~ /^removed /);
|
|---|
| 4218 | pb_log(0,"$_");
|
|---|
| 4219 | }
|
|---|
| 4220 | } else {
|
|---|
| 4221 | # In "Check" mode we need to compare the 2 lists (real and theoritical)
|
|---|
| 4222 | while (<LOG>) {
|
|---|
| 4223 | # Get package name and remove what is in extra for the theoritical list (arch at the end)
|
|---|
| 4224 | chomp();
|
|---|
| 4225 | # skip find errors
|
|---|
| 4226 | next if (/^find:/);
|
|---|
| 4227 | my $p = $_;
|
|---|
| 4228 | $p =~ s/\.(i[3456]86|x86_64|noarch|src)\.rpm$//;
|
|---|
| 4229 | $p =~ s/_(i[3456]86|amd64|all)\.deb$//;
|
|---|
| 4230 | $p =~ s/(-0\.[0-9]{8})[0-9]{6}/$1*/ if ((defined $testver) && (defined $testver->{$ENV{'PBPROJ'}}) && ($testver->{$ENV{'PBPROJ'}} =~ /true/i));
|
|---|
| 4231 | $p =~ s/(-r|_p[0-9]+)\.ebuild/$1*/ if ((defined $testver) && (defined $testver->{$ENV{'PBPROJ'}}) && ($testver->{$ENV{'PBPROJ'}} =~ /true/i));
|
|---|
| 4232 | $theorlist{$p} = -2 if (not defined $theorlist{$p});
|
|---|
| 4233 | $theorlist{$p} = $theorlist{$p} + 1;
|
|---|
| 4234 | }
|
|---|
| 4235 | pb_log(2,"theorlist after check: ".Dumper(%theorlist)."\n");
|
|---|
| 4236 | }
|
|---|
| 4237 | close(LOG);
|
|---|
| 4238 |
|
|---|
| 4239 | # Nothing more for the cleanssh case
|
|---|
| 4240 | return if ($antype eq "Clean");
|
|---|
| 4241 |
|
|---|
| 4242 | if ($antype eq "Check") {
|
|---|
| 4243 | my ($chkex) = pb_conf_get_if("checkexclude");
|
|---|
| 4244 | my $vmbuildlist = "";
|
|---|
| 4245 | my $vebuildlist = "";
|
|---|
| 4246 | my $rmbuildlist = "";
|
|---|
| 4247 | my @pt = pb_conf_get_if("vmlist","velist","rmlist");
|
|---|
| 4248 | foreach my $t (sort keys %theorlist) {
|
|---|
| 4249 | if (defined $theorlist{$t} and $theorlist{$t} >= 1) {
|
|---|
| 4250 | pb_log(1,"Packages found for $t\n");
|
|---|
| 4251 | } elsif (defined $theorlist{$t} and $theorlist{$t} < 0) {
|
|---|
| 4252 | pb_log(0,"Extra Package found for $t\n");
|
|---|
| 4253 | } else {
|
|---|
| 4254 | pb_log(2,"Analyzing $t\n");
|
|---|
| 4255 | my ($os,$ver,$arch,$package) = split(/\//,$t);
|
|---|
| 4256 | # Some distro have no arch subdir
|
|---|
| 4257 | if (not defined $package) {
|
|---|
| 4258 | $package = $arch;
|
|---|
| 4259 | # TODO: If both arch have failed, we just make the last one
|
|---|
| 4260 | $arch = $archlist{$t} if (defined $archlist{$t});
|
|---|
| 4261 | }
|
|---|
| 4262 | my $pbos = pb_distro_get_context("$os-$ver-$arch");
|
|---|
| 4263 | my $pkgn = $package;
|
|---|
| 4264 | if ($pbos->{'type'} ne "deb") {
|
|---|
| 4265 | # package name is more easily found from the end for non deb
|
|---|
| 4266 | # as '-' is the separator, but it can also be used in names
|
|---|
| 4267 | $pkgn = reverse($package);
|
|---|
| 4268 | # search the second '-' and isolate the now last part which is the full name
|
|---|
| 4269 | $pkgn =~ s/([^-]+)-([^-]+)-([\S])+$/$3/;
|
|---|
| 4270 | } else {
|
|---|
| 4271 | $pkgn =~ s/([^_]+)_([\S])+$/$2/;
|
|---|
| 4272 | }
|
|---|
| 4273 | my $found = 0;
|
|---|
| 4274 | # Handle the exclusion of OSes
|
|---|
| 4275 | my $excl = "";
|
|---|
| 4276 | $excl .= $chkex->{$pkgn} if (defined $chkex->{$pkgn});
|
|---|
| 4277 | $excl .= $chkex->{"all"} if (defined $chkex->{"all"});
|
|---|
| 4278 |
|
|---|
| 4279 | pb_log(2,"Searching in excl $excl\n");
|
|---|
| 4280 | foreach my $ex (split(/,/,$excl)) {
|
|---|
| 4281 | $found = 1 if ("$os-$ver-$arch" =~ /^$ex/);
|
|---|
| 4282 | }
|
|---|
| 4283 | # Skip as excluded
|
|---|
| 4284 | next if ($found == 1);
|
|---|
| 4285 | pb_log(0,"Package NOT found for $t\n");
|
|---|
| 4286 | # Avoid duplicates in list
|
|---|
| 4287 | next if ($vmbuildlist =~ /$os-$ver-$arch/);
|
|---|
| 4288 | next if ($vebuildlist =~ /$os-$ver-$arch/);
|
|---|
| 4289 | next if ($rmbuildlist =~ /$os-$ver-$arch/);
|
|---|
| 4290 | # check with which method we need to build
|
|---|
| 4291 | if ((defined $pt[0]->{$ENV{'PBPROJ'}}) and ($pt[0]->{$ENV{'PBPROJ'}} =~ /$os-$ver-$arch/)) {
|
|---|
| 4292 | $vmbuildlist = "$os-$ver-$arch" if ($vmbuildlist eq "");
|
|---|
| 4293 | $vmbuildlist .= ",$os-$ver-$arch" if ($vmbuildlist !~ /$os-$ver-$arch/);
|
|---|
| 4294 | next;
|
|---|
| 4295 | }
|
|---|
| 4296 | if ((defined $pt[1]->{$ENV{'PBPROJ'}}) and ($pt[1]->{$ENV{'PBPROJ'}} =~ /$os-$ver-$arch/)) {
|
|---|
| 4297 | $vebuildlist = "$os-$ver-$arch" if ($vebuildlist eq "");
|
|---|
| 4298 | $vebuildlist .= ",$os-$ver-$arch" if ($vebuildlist !~ /$os-$ver-$arch/);
|
|---|
| 4299 | next;
|
|---|
| 4300 | }
|
|---|
| 4301 | if ((defined $pt[2]->{$ENV{'PBPROJ'}}) and ($pt[2]->{$ENV{'PBPROJ'}} =~ /$os-$ver-$arch/)) {
|
|---|
| 4302 | $rmbuildlist = "$os-$ver-$arch" if ($rmbuildlist eq "");
|
|---|
| 4303 | $rmbuildlist .= ",$os-$ver-$arch" if ($rmbuildlist !~ /$os-$ver-$arch/);
|
|---|
| 4304 | }
|
|---|
| 4305 | }
|
|---|
| 4306 | }
|
|---|
| 4307 | # If we want to rebuild automatically, let's do it
|
|---|
| 4308 | if (defined $opts{'rebuild'}) {
|
|---|
| 4309 | # SandBox or CMS
|
|---|
| 4310 | pb_log(0,"Rebuilding from SandBox\n");
|
|---|
| 4311 | pb_log(0,"for VMs: $vmbuildlist\n") if ($vmbuildlist ne "");
|
|---|
| 4312 | pb_log(0,"for VEs: $vebuildlist\n") if ($vebuildlist ne "");
|
|---|
| 4313 | pb_log(0,"for RMs: $rmbuildlist\n") if ($rmbuildlist ne "");
|
|---|
| 4314 | pb_cms2build("SandBox");
|
|---|
| 4315 | # Which mode
|
|---|
| 4316 | $ENV{'PBV'} = $vmbuildlist;
|
|---|
| 4317 | pb_build2v("vm","build") if ($vmbuildlist ne "");
|
|---|
| 4318 | $ENV{'PBV'} = $vebuildlist;
|
|---|
| 4319 | pb_build2v("ve","build") if ($vebuildlist ne "");
|
|---|
| 4320 | $ENV{'PBV'} = $rmbuildlist;
|
|---|
| 4321 | pb_build2v("rm","build") if ($rmbuildlist ne "");
|
|---|
| 4322 | }
|
|---|
| 4323 | # For the check part this is now finished
|
|---|
| 4324 | return;
|
|---|
| 4325 | }
|
|---|
| 4326 |
|
|---|
| 4327 | print ANN << "EOF";
|
|---|
| 4328 | </TR>
|
|---|
| 4329 | </TABLE>
|
|---|
| 4330 | </p>
|
|---|
| 4331 |
|
|---|
| 4332 | <p>As usual source packages are also available in the same directory.</p>
|
|---|
| 4333 |
|
|---|
| 4334 | <p>
|
|---|
| 4335 | Changes are :
|
|---|
| 4336 | </p>
|
|---|
| 4337 | <p>
|
|---|
| 4338 | EOF
|
|---|
| 4339 | # Get each package changelog content
|
|---|
| 4340 | foreach my $f (sort(@files)) {
|
|---|
| 4341 | open(IN,"$f") || die "Unable to read $f:$!";
|
|---|
| 4342 | while (<IN>) {
|
|---|
| 4343 | print ANN $_;
|
|---|
| 4344 | }
|
|---|
| 4345 | close(IN);
|
|---|
| 4346 | print ANN "</p><p>\n";
|
|---|
| 4347 | }
|
|---|
| 4348 | print ANN "</p>\n";
|
|---|
| 4349 | close(ANN);
|
|---|
| 4350 |
|
|---|
| 4351 | # Allow for modification
|
|---|
| 4352 | my $editor = "vi";
|
|---|
| 4353 | $editor = $ENV{'EDITOR'} if (defined $ENV{'EDITOR'});
|
|---|
| 4354 | pb_system("$editor $ENV{'PBTMP'}/announce.html","Allowing modification of the announce","noredir");
|
|---|
| 4355 |
|
|---|
| 4356 | # Store it in DB for external usage (Web pages generation)
|
|---|
| 4357 | my $dbh = pb_connect_db();
|
|---|
| 4358 |
|
|---|
| 4359 | # To read whole file
|
|---|
| 4360 | local $/;
|
|---|
| 4361 | open(ANN,"$ENV{'PBTMP'}/announce.html") || die "Unable to read $ENV{'PBTMP'}/announce.html: $!";
|
|---|
| 4362 | my $announce = <ANN>;
|
|---|
| 4363 | close(ANN);
|
|---|
| 4364 |
|
|---|
| 4365 | pb_log(2,"INSERT INTO announces VALUES (NULL, $pbdate, $announce)");
|
|---|
| 4366 | my $sth = $dbh->prepare(qq{INSERT INTO announces VALUES (NULL,?,?)})
|
|---|
| 4367 | || die "Unable to insert into db";
|
|---|
| 4368 | $sth->execute($pbdate, $announce);
|
|---|
| 4369 | $sth->finish();
|
|---|
| 4370 | $dbh->disconnect;
|
|---|
| 4371 |
|
|---|
| 4372 | # Then deliver it on the Web
|
|---|
| 4373 | # $TOOLHOME/livwww www
|
|---|
| 4374 |
|
|---|
| 4375 | # Mail it to project's ML
|
|---|
| 4376 | open(ML,"| w3m -dump -T text/html > $ENV{'PBTMP'}/announce.txt") || die "Unable to create $ENV{'PBTMP'}/announce.txt: $!";
|
|---|
| 4377 | print ML << 'EOF';
|
|---|
| 4378 | <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/x html1/DTD/xhtml1-strict.dtd">
|
|---|
| 4379 |
|
|---|
| 4380 | <html xmlns="http://www.w3.org/1999/xhtml" dir="ltr" xml:lang="en" lang="en">
|
|---|
| 4381 | <head>
|
|---|
| 4382 | </head>
|
|---|
| 4383 | <body>
|
|---|
| 4384 | <p>
|
|---|
| 4385 | EOF
|
|---|
| 4386 | open(ANN,"$ENV{'PBTMP'}/announce.html") || die "Unable to read $ENV{'PBTMP'}/announce.html: $!";
|
|---|
| 4387 | while(<ANN>) {
|
|---|
| 4388 | print ML $_;
|
|---|
| 4389 | }
|
|---|
| 4390 | print ML << 'EOF';
|
|---|
| 4391 | </body>
|
|---|
| 4392 | </html>
|
|---|
| 4393 | EOF
|
|---|
| 4394 | close(ML);
|
|---|
| 4395 |
|
|---|
| 4396 | # To read whole file
|
|---|
| 4397 | local $/;
|
|---|
| 4398 | open(ANN,"$ENV{'PBTMP'}/announce.txt") || die "Unable to read $ENV{'PBTMP'}/announce.txt: $!";
|
|---|
| 4399 | my $msg = <ANN>;
|
|---|
| 4400 | close(ANN);
|
|---|
| 4401 |
|
|---|
| 4402 | # Preparation of headers
|
|---|
| 4403 | eval
|
|---|
| 4404 | {
|
|---|
| 4405 | require Mail::Sendmail;
|
|---|
| 4406 | Mail::Sendmail->import();
|
|---|
| 4407 | };
|
|---|
| 4408 | if ($@) {
|
|---|
| 4409 | # Mail::Sendmail not found not sending mail !
|
|---|
| 4410 | pb_log(0,"No Mail::Sendmail module found so not sending any mail !\n");
|
|---|
| 4411 | } else {
|
|---|
| 4412 | my ($pbml,$pbsmtp) = pb_conf_get("pbml","pbsmtp");
|
|---|
| 4413 | my %mail = (
|
|---|
| 4414 | To => $pbml->{$ENV{'PBPROJ'}},
|
|---|
| 4415 | From => $pbpackager->{$ENV{'PBPROJ'}},
|
|---|
| 4416 | Smtp => $pbsmtp->{$ENV{'PBPROJ'}},
|
|---|
| 4417 | Body => $msg,
|
|---|
| 4418 | Subject => "[ANNOUNCE] $sl",
|
|---|
| 4419 | );
|
|---|
| 4420 |
|
|---|
| 4421 | # Send mail
|
|---|
| 4422 | if (! sendmail(%mail)) {
|
|---|
| 4423 | if ((defined $Mail::Sendmail::error) and (defined $Mail::Sendmail::log)) {
|
|---|
| 4424 | die "Unable to send mail ($Mail::Sendmail::error): $Mail::Sendmail::log";
|
|---|
| 4425 | }
|
|---|
| 4426 | }
|
|---|
| 4427 | }
|
|---|
| 4428 | }
|
|---|
| 4429 |
|
|---|
| 4430 | #
|
|---|
| 4431 | # Creates a set of HTML file containing the news for the project
|
|---|
| 4432 | # based on what has been generated by the pb_announce function
|
|---|
| 4433 | #
|
|---|
| 4434 | sub pb_web_news2html {
|
|---|
| 4435 |
|
|---|
| 4436 | my $dest = shift || $ENV{'PBTMP'};
|
|---|
| 4437 |
|
|---|
| 4438 | # Get all required parameters
|
|---|
| 4439 | my ($pkgv, $pkgt) = pb_conf_get_if("pkgver","pkgtag");
|
|---|
| 4440 |
|
|---|
| 4441 |
|
|---|
| 4442 | my $dbh = pb_connect_db();
|
|---|
| 4443 | # For date handling
|
|---|
| 4444 | $ENV{LANGUAGE}="C";
|
|---|
| 4445 | my $firstjan = strftime("%Y-%m-%d", 0, 0, 0, 1, 0, localtime->year(), 0, 0, -1);
|
|---|
| 4446 | my $oldfirst = strftime("%Y-%m-%d", 0, 0, 0, 1, 0, localtime->year()-1, 0, 0, -1);
|
|---|
| 4447 | pb_log(2,"firstjan: $firstjan, oldfirst: $oldfirst, pbdate:$pbdate\n");
|
|---|
| 4448 | my $all = $dbh->selectall_arrayref("SELECT id,date,announce FROM announces ORDER BY date DESC");
|
|---|
| 4449 | my %news;
|
|---|
| 4450 | $news{"cy"} = ""; # current year's news
|
|---|
| 4451 | $news{"ly"} = ""; # last year news
|
|---|
| 4452 | $news{"py"} = ""; # previous years news
|
|---|
| 4453 | $news{"fp"} = ""; # first page news
|
|---|
| 4454 | my $cpt = 4; # how many news for first page
|
|---|
| 4455 | # Extract info from DB
|
|---|
| 4456 | foreach my $row (@$all) {
|
|---|
| 4457 | my ($id, $date, $announce) = @$row;
|
|---|
| 4458 | $news{"cy"} = $news{"cy"}."<p><B>$date</B> $announce\n" if ((($date cmp $pbdate) le 0) && (($firstjan cmp $date) le 0));
|
|---|
| 4459 | $news{"ly"} = $news{"ly"}."<p><B>$date</B> $announce\n" if ((($date cmp $firstjan) le 0) && (($oldfirst cmp $date) le 0));
|
|---|
| 4460 | $news{"py"} = $news{"py"}."<p><B>$date</B> $announce\n" if (($date cmp $oldfirst) le 0);
|
|---|
| 4461 | $news{"fp"} = $news{"fp"}."<p><B>$date</B> $announce\n" if ($cpt > 0);
|
|---|
| 4462 | $cpt--;
|
|---|
| 4463 | }
|
|---|
| 4464 | pb_log(1,"news{fp}: ".$news{"fp"}."\n");
|
|---|
| 4465 | $dbh->disconnect;
|
|---|
| 4466 |
|
|---|
| 4467 | # Generate the HTML content
|
|---|
| 4468 | foreach my $pref (keys %news) {
|
|---|
| 4469 | open(NEWS,"> $dest/pb_web_$pref"."news.html") || die "Unable to create $dest/pb_web_$pref"."news.html: $!";
|
|---|
| 4470 | print NEWS "$news{$pref}";
|
|---|
| 4471 | close(NEWS);
|
|---|
| 4472 | }
|
|---|
| 4473 | }
|
|---|
| 4474 |
|
|---|
| 4475 | sub pb_connect_db {
|
|---|
| 4476 |
|
|---|
| 4477 | # Store in DB for external usage (Web pages generation)
|
|---|
| 4478 | my $db = "$ENV{'PBCONFDIR'}/announces3.sql";
|
|---|
| 4479 |
|
|---|
| 4480 | my $precmd = "";
|
|---|
| 4481 | if (! -f $db) {
|
|---|
| 4482 | $precmd = "CREATE TABLE announces (id INTEGER PRIMARY KEY AUTOINCREMENT, date DATE, announce VARCHAR[65535])";
|
|---|
| 4483 | # we should add the $db to the VCS as well here
|
|---|
| 4484 | }
|
|---|
| 4485 |
|
|---|
| 4486 | my $dbh = DBI->connect("dbi:SQLite:dbname=$db","","",
|
|---|
| 4487 | { RaiseError => 1, AutoCommit => 1 })
|
|---|
| 4488 | || die "Unable to connect to $db";
|
|---|
| 4489 |
|
|---|
| 4490 | if ($precmd ne "") {
|
|---|
| 4491 | my $sth = $dbh->prepare(qq{$precmd})
|
|---|
| 4492 | || die "Unable to create table into $db";
|
|---|
| 4493 | $sth->execute();
|
|---|
| 4494 | }
|
|---|
| 4495 |
|
|---|
| 4496 | return($dbh);
|
|---|
| 4497 | }
|
|---|
| 4498 |
|
|---|
| 4499 |
|
|---|
| 4500 | # Return the SSH key file to use
|
|---|
| 4501 | # Potentially create it if needed
|
|---|
| 4502 |
|
|---|
| 4503 | sub pb_ssh_get {
|
|---|
| 4504 |
|
|---|
| 4505 | my $create = shift || 0; # Do not create keys by default. In that case prefer native keys, not pb's ones
|
|---|
| 4506 | my $target = shift || "localhost";
|
|---|
| 4507 | my $nport = shift || "22";
|
|---|
| 4508 |
|
|---|
| 4509 | my ($pbagent) = pb_conf_get_if("pbusesshagent");
|
|---|
| 4510 | # use ssh-agent if asked so.
|
|---|
| 4511 | return(undef) if (($create == 0) && (defined $pbagent->{$ENV{'PBPROJ'}}) && ($pbagent->{$ENV{'PBPROJ'}} =~ /true/io));
|
|---|
| 4512 |
|
|---|
| 4513 | # Check the SSH environment
|
|---|
| 4514 | my $keyfile = undef;
|
|---|
| 4515 |
|
|---|
| 4516 | # Check whether ecdsa is accepted by the remote host
|
|---|
| 4517 | my $ecdsa = 0;
|
|---|
| 4518 | my $dsa = 0;
|
|---|
| 4519 | open(SCAN,"ssh-keyscan -p $nport -t ecdsa $target 2>/dev/null |") || pb_log(0,"Unable to check ECDSA support for $target");
|
|---|
| 4520 | while(<SCAN>) {
|
|---|
| 4521 | $ecdsa = 1 if ($_ =~ /ecdsa-/);
|
|---|
| 4522 | pb_log(2,"Found ECDSA support on $target ($nport)\n");
|
|---|
| 4523 | }
|
|---|
| 4524 | close(SCAN);
|
|---|
| 4525 |
|
|---|
| 4526 | open(SCAN,"ssh-keyscan -p $nport -t dsa $target 2>/dev/null |") || pb_log(0,"Unable to check DSA support for $target");
|
|---|
| 4527 | while(<SCAN>) {
|
|---|
| 4528 | $dsa = 1 if ($_ =~ /ssh-dss/);
|
|---|
| 4529 | pb_log(2,"Found DSA support on $target ($nport)\n");
|
|---|
| 4530 | }
|
|---|
| 4531 | close(SCAN);
|
|---|
| 4532 |
|
|---|
| 4533 | # We have specific keys by default - create them if needed
|
|---|
| 4534 | if (!(-e "$ENV{'HOME'}/.ssh/pb_ecdsa") && ($create eq 1)) {
|
|---|
| 4535 | my $res = pb_system("ssh-keygen -q -b 1024 -N '' -f $ENV{'HOME'}/.ssh/pb_ecdsa -t ecdsa","Generating ECDSA SSH keys for pb");
|
|---|
| 4536 | if (($res != 0) && !(-e "$ENV{'HOME'}/.ssh/pb_dsa") && ($create eq 1)) {
|
|---|
| 4537 | # ecdsa may not be supported if old ssh
|
|---|
| 4538 | pb_system("ssh-keygen -q -b 1024 -N '' -f $ENV{'HOME'}/.ssh/pb_dsa -t dsa","Generating DSA SSH keys for pb");
|
|---|
| 4539 | }
|
|---|
| 4540 | }
|
|---|
| 4541 |
|
|---|
| 4542 | #$keyfile = "$ENV{'HOME'}/.ssh/id_rsa" if (-s "$ENV{'HOME'}/.ssh/id_rsa");
|
|---|
| 4543 | # We still favoud DSA and fall back to ECDSA if not available
|
|---|
| 4544 | if ($dsa != 0) {
|
|---|
| 4545 | # And we favour a specific key over a generic one except if in delivery to ftp server
|
|---|
| 4546 | $keyfile = "$ENV{'HOME'}/.ssh/id_dsa" if ((-s "$ENV{'HOME'}/.ssh/id_dsa") && ($create eq 0));
|
|---|
| 4547 | $keyfile = "$ENV{'HOME'}/.ssh/pb_dsa" if (-s "$ENV{'HOME'}/.ssh/pb_dsa");
|
|---|
| 4548 | } else {
|
|---|
| 4549 | # And we favour a specific key over a generic one except if in delivery to ftp server
|
|---|
| 4550 | $keyfile = "$ENV{'HOME'}/.ssh/id_ecdsa" if ((-s "$ENV{'HOME'}/.ssh/id_ecdsa") && ($ecdsa != 0) && ($create eq 0));
|
|---|
| 4551 | $keyfile = "$ENV{'HOME'}/.ssh/pb_ecdsa" if ((-s "$ENV{'HOME'}/.ssh/pb_ecdsa") && ($ecdsa != 0));
|
|---|
| 4552 | }
|
|---|
| 4553 | if (defined $keyfile) {
|
|---|
| 4554 | pb_log(2,"Using ssh key file $keyfile\n");
|
|---|
| 4555 | } else {
|
|---|
| 4556 | pb_log(0, "Unable to find your public ssh key under $ENV{'HOME'}/.ssh\n");
|
|---|
| 4557 | }
|
|---|
| 4558 | return($keyfile);
|
|---|
| 4559 | }
|
|---|
| 4560 |
|
|---|
| 4561 |
|
|---|
| 4562 | # Returns the pid of a running VM command using a specific VM file, and the port used if the VM exists
|
|---|
| 4563 | sub pb_check_ps {
|
|---|
| 4564 | my $vmcmd = shift;
|
|---|
| 4565 | my $vmm = shift;
|
|---|
| 4566 | my $vexist = 0; # FALSE by default
|
|---|
| 4567 | my $vmport = undef; # NONE by default
|
|---|
| 4568 |
|
|---|
| 4569 | open(PS, "ps auxhww|") || die "Unable to call ps";
|
|---|
| 4570 | while (<PS>) {
|
|---|
| 4571 | next if (! /$vmcmd/);
|
|---|
| 4572 | next if (! /$vmm/);
|
|---|
| 4573 | my $void1;
|
|---|
| 4574 | ($void1, $vexist, $vmport) = split(/ +/,$_,3);
|
|---|
| 4575 | pb_log(2,"pb_check_ps $vmport\n");
|
|---|
| 4576 | $vmport =~ s/.*=tcp:127\.0\.0\.1:([0-9]+)-:22.*/$1/;
|
|---|
| 4577 | chomp($vmport);
|
|---|
| 4578 | pb_log(2,"pb_check_ps found a VM $vexist using port $vmport\n");
|
|---|
| 4579 | last;
|
|---|
| 4580 | }
|
|---|
| 4581 | return($vexist,$vmport);
|
|---|
| 4582 | }
|
|---|
| 4583 |
|
|---|
| 4584 |
|
|---|
| 4585 | sub pb_extract_build_files {
|
|---|
| 4586 |
|
|---|
| 4587 | my $src=shift;
|
|---|
| 4588 | my $dir=shift;
|
|---|
| 4589 | my $ddir=shift;
|
|---|
| 4590 | my $mandatory=shift || "spec";
|
|---|
| 4591 |
|
|---|
| 4592 | my $flag = "mayfail" if (($mandatory eq "patch") || ($mandatory eq "src"));
|
|---|
| 4593 | my $res;
|
|---|
| 4594 |
|
|---|
| 4595 | if ($src =~ /tar\.gz$/) {
|
|---|
| 4596 | $res = pb_system("tar xfpz $src $dir","Extracting $mandatory files from $src",$flag);
|
|---|
| 4597 | } elsif ($src =~ /tar\.bz2$/) {
|
|---|
| 4598 | $res = pb_system("tar xfpj $src $dir","Extracting $mandatory files from $src",$flag);
|
|---|
| 4599 | } else {
|
|---|
| 4600 | die "Unknown compression algorithm for $src";
|
|---|
| 4601 | }
|
|---|
| 4602 | # If not mandatory return now
|
|---|
| 4603 | return() if (($res != 0) and (($mandatory eq "patch") || ($mandatory eq "src")));
|
|---|
| 4604 | return(pb_move_extracted_files($dir,$ddir));
|
|---|
| 4605 | }
|
|---|
| 4606 |
|
|---|
| 4607 | sub pb_move_extracted_files {
|
|---|
| 4608 |
|
|---|
| 4609 | my $dir = shift;
|
|---|
| 4610 | my $ddir = shift;
|
|---|
| 4611 | my @files;
|
|---|
| 4612 |
|
|---|
| 4613 | # In a recursive function , we need a local var as DIR handle
|
|---|
| 4614 | my $bdir;
|
|---|
| 4615 |
|
|---|
| 4616 | opendir($bdir,"$dir") || confess "Unable to open directory $dir: $!";
|
|---|
| 4617 | foreach my $f (readdir($bdir)) {
|
|---|
| 4618 | next if ($f =~ /^\./);
|
|---|
| 4619 | # Skip potential patch dir
|
|---|
| 4620 | next if ($f =~ /^pbpatch/);
|
|---|
| 4621 | # Skip potential source dir
|
|---|
| 4622 | next if ($f =~ /^pbsrc/);
|
|---|
| 4623 | # Skip potential backup files
|
|---|
| 4624 | next if ($f =~ /~$/);
|
|---|
| 4625 | if ((-d "$dir/$f") && (! -l "$dir/$f")) {
|
|---|
| 4626 | # Case of the bug debian subdir
|
|---|
| 4627 | pb_mkdir_p("$ddir/$f");
|
|---|
| 4628 | push @files,pb_move_extracted_files("$dir/$f","$ddir/$f");
|
|---|
| 4629 | } else {
|
|---|
| 4630 | move("$dir/$f","$ddir") || die "Unable to move $dir/$f to $ddir";
|
|---|
| 4631 | pb_log(2,"mv $dir/$f $ddir\n");
|
|---|
| 4632 | push @files,"$ddir/$f";
|
|---|
| 4633 | }
|
|---|
| 4634 | }
|
|---|
| 4635 | closedir($bdir);
|
|---|
| 4636 | # Not enough but still a first cleanup
|
|---|
| 4637 | pb_rm_rf("$dir");
|
|---|
| 4638 | return(@files);
|
|---|
| 4639 | }
|
|---|
| 4640 |
|
|---|
| 4641 | sub pb_list_bfiles {
|
|---|
| 4642 |
|
|---|
| 4643 | my $dir = shift;
|
|---|
| 4644 | my $pbpkg = shift;
|
|---|
| 4645 | my $bfiles = shift;
|
|---|
| 4646 | my $pkgfiles = shift;
|
|---|
| 4647 | my $supfiles = shift;
|
|---|
| 4648 | # subdir to keep if recursive mode, empty by default
|
|---|
| 4649 | my $subdir = shift || "";
|
|---|
| 4650 | # In a recursive function , we need a local var as DIR handle
|
|---|
| 4651 | my $bdir;
|
|---|
| 4652 |
|
|---|
| 4653 | pb_log(2,"DEBUG: entering pb_list_bfiles in $dir: ".Dumper($bfiles)."\n");
|
|---|
| 4654 | opendir($bdir,"$dir") || die "Unable to open dir $dir: $!";
|
|---|
| 4655 | foreach my $f (readdir($bdir)) {
|
|---|
| 4656 | pb_log(3,"DEBUG: pb_list_bfiles found $f\n");
|
|---|
| 4657 | next if ($f =~ /^\./);
|
|---|
| 4658 | if (-d "$dir/$f") {
|
|---|
| 4659 | # Recurse for directories (Debian 3.0 format e.g.)
|
|---|
| 4660 | pb_log(2,"DEBUG: pb_list_bfiles recurse in $dir/$f\n");
|
|---|
| 4661 | pb_list_bfiles("$dir/$f",$pbpkg,$bfiles,$pkgfiles,$supfiles,$f);
|
|---|
| 4662 | next;
|
|---|
| 4663 | }
|
|---|
| 4664 |
|
|---|
| 4665 | my $key = $f;
|
|---|
| 4666 | # if recursive then store also the subdir
|
|---|
| 4667 | $key = "$subdir/$f" if ($subdir ne "");
|
|---|
| 4668 | $bfiles->{$key} = "$dir/$f";
|
|---|
| 4669 | $bfiles->{$key} =~ s~$ENV{'PBROOTDIR'}~~;
|
|---|
| 4670 | if (defined $supfiles->{$pbpkg}) {
|
|---|
| 4671 | $pkgfiles->{$key} = "$dir/$f" if ($f =~ /$supfiles->{$pbpkg}/);
|
|---|
| 4672 | }
|
|---|
| 4673 | }
|
|---|
| 4674 | closedir($bdir);
|
|---|
| 4675 | pb_log(2,"DEBUG: exiting pb_list_bfiles: ".Dumper($bfiles)."\n");
|
|---|
| 4676 | }
|
|---|
| 4677 |
|
|---|
| 4678 | sub pb_add_comma {
|
|---|
| 4679 |
|
|---|
| 4680 | my $str = shift;
|
|---|
| 4681 | my $addstr = shift;
|
|---|
| 4682 |
|
|---|
| 4683 | $str .= "," if (defined $str);
|
|---|
| 4684 | $str .= $addstr;
|
|---|
| 4685 | return($str);
|
|---|
| 4686 | }
|
|---|
| 4687 |
|
|---|
| 4688 | sub pb_list_sfiles {
|
|---|
| 4689 |
|
|---|
| 4690 | my $sdir = shift;
|
|---|
| 4691 | my $ptr = shift;
|
|---|
| 4692 | my $pbos = shift;
|
|---|
| 4693 | my $extdir = shift;
|
|---|
| 4694 |
|
|---|
| 4695 | pb_log(2,"DEBUG: entering pb_list_sfiles: ".Dumper($ptr)."\n");
|
|---|
| 4696 | my $key = "$pbos->{'name'}-$pbos->{'version'}-$pbos->{'arch'}";
|
|---|
| 4697 |
|
|---|
| 4698 | # Prepare local sources for this distro - They are always applied first - May be a problem one day
|
|---|
| 4699 | # This function works for both patches and additional sources
|
|---|
| 4700 | foreach my $p (sort(<$sdir/*>)) {
|
|---|
| 4701 | $ptr->{$key} = pb_add_comma($ptr->{$key},"file://$p") if (($p =~ /\.all$/) || ($p =~ /\.$pbos->{'os'}$/) || ($p =~ /\.$pbos->{'type'}$/) || ($p =~ /\.$pbos->{'family'}$/) || ($p =~ /\.$pbos->{'name'}$/) || ($p =~ /\.$pbos->{'name'}-$pbos->{'version'}$/) ||($p =~ /\.$pbos->{'name'}-$pbos->{'version'}-$pbos->{'arch'}$/));
|
|---|
| 4702 | }
|
|---|
| 4703 |
|
|---|
| 4704 | # Prepare also remote sources to be included - Applied after the local ones
|
|---|
| 4705 | foreach my $p ("all","$pbos->{'os'}","$pbos->{'type'}","$pbos->{'family'}","$pbos->{'name'}","$pbos->{'name'}-$pbos->{'version'}","$pbos->{'name'}-$pbos->{'version'}-$pbos->{'arch'}") {
|
|---|
| 4706 | my $f = "$extdir.".".$p";
|
|---|
| 4707 | next if (not -f $f);
|
|---|
| 4708 | if (not open(PATCH,$f)) {
|
|---|
| 4709 | pb_display("Unable to open existing external source file content $f\n");
|
|---|
| 4710 | next;
|
|---|
| 4711 | }
|
|---|
| 4712 | while (<PATCH>) {
|
|---|
| 4713 | chomp();
|
|---|
| 4714 | $ptr->{$key} = pb_add_comma($ptr->{$key},"$_");
|
|---|
| 4715 | }
|
|---|
| 4716 | close(PATCH);
|
|---|
| 4717 | }
|
|---|
| 4718 | pb_log(2,"DEBUG: exiting pb_list_sfiles: ".Dumper($ptr)."\n");
|
|---|
| 4719 | return($ptr);
|
|---|
| 4720 | }
|
|---|
| 4721 |
|
|---|
| 4722 | #
|
|---|
| 4723 | # Return the list of packages we are working on in a non CMS action
|
|---|
| 4724 | #
|
|---|
| 4725 | sub pb_get_pkg {
|
|---|
| 4726 |
|
|---|
| 4727 | my @pkgs = ();
|
|---|
| 4728 |
|
|---|
| 4729 | # In script actions that file may not exist.
|
|---|
| 4730 | return(\@pkgs) if ((not defined $ENV{'PBDESTDIR'}) || (not defined $ENV{'PBPROJVER'}) || (not defined $ENV{'PBPROJTAG'}) || (! -f "$ENV{'PBDESTDIR'}/$ENV{'PBPROJVER'}-$ENV{'PBPROJTAG'}.pb"));
|
|---|
| 4731 |
|
|---|
| 4732 | my ($var) = pb_conf_read("$ENV{'PBDESTDIR'}/$ENV{'PBPROJVER'}-$ENV{'PBPROJTAG'}.pb","pbpkg");
|
|---|
| 4733 | @pkgs = keys %$var if (defined $var);
|
|---|
| 4734 |
|
|---|
| 4735 | pb_log(0,"Packages: ".join(',',@pkgs)."\n") if (@pkgs);
|
|---|
| 4736 | return(\@pkgs);
|
|---|
| 4737 | }
|
|---|
| 4738 |
|
|---|
| 4739 | # Manages VM/RM SSH port communication
|
|---|
| 4740 | sub pb_get_port {
|
|---|
| 4741 |
|
|---|
| 4742 | my $port = shift;
|
|---|
| 4743 | my $pbos = shift;
|
|---|
| 4744 | my $cmt = shift;
|
|---|
| 4745 | my $nport;
|
|---|
| 4746 |
|
|---|
| 4747 | die "No port passed in parameter. Report to dev team\n" if (not defined $port);
|
|---|
| 4748 | # key is project on VM, but machine tuple for RM
|
|---|
| 4749 | if ($cmt =~ /^RM/i) {
|
|---|
| 4750 | $nport = $port->{"$pbos->{'name'}-$pbos->{'version'}-$pbos->{'arch'}"};
|
|---|
| 4751 | } else {
|
|---|
| 4752 | $nport = $port->{$ENV{'PBPROJ'}};
|
|---|
| 4753 | }
|
|---|
| 4754 | pb_log(2,"pb_get_port with $nport\n");
|
|---|
| 4755 | if ($cmt =~ /^VM/i) {
|
|---|
| 4756 | # Maybe a port was given as parameter so overwrite
|
|---|
| 4757 | $nport = "$pbport" if (defined $pbport);
|
|---|
| 4758 | # Maybe in // mode so use the env var set up as an offset to the base port
|
|---|
| 4759 | $nport = $nport + $ENV{'PBVMPORT'} -1 if ((defined $pbparallel) && (defined $ENV{'PBVMPORT'}));
|
|---|
| 4760 | }
|
|---|
| 4761 | pb_log(2,"pb_get_port returns $nport\n");
|
|---|
| 4762 | return($nport);
|
|---|
| 4763 | }
|
|---|
| 4764 |
|
|---|
| 4765 | sub pb_set_port {
|
|---|
| 4766 |
|
|---|
| 4767 | my ($pid,$ident) = @_;
|
|---|
| 4768 | pb_log(2,"pb_set_port for VM ($pid), id $ident\n");
|
|---|
| 4769 | $ENV{'PBVMPORT'} = $ident;
|
|---|
| 4770 | pb_log(2,"pb_set_port sets PBVMPORT in env to $ENV{'PBVMPORT'}\n");
|
|---|
| 4771 | }
|
|---|
| 4772 |
|
|---|
| 4773 | sub pb_set_parallel {
|
|---|
| 4774 |
|
|---|
| 4775 | my $vtype = shift;
|
|---|
| 4776 |
|
|---|
| 4777 | pb_log(2,"pb_set_parallel vtype: $vtype\n");
|
|---|
| 4778 | # Take care of memory size if VM, parallel mode and more than 1 action
|
|---|
| 4779 | if ((defined $pbparallel) && ($pbparallel ne 1) && ($vtype eq "vm")) {
|
|---|
| 4780 | eval
|
|---|
| 4781 | {
|
|---|
| 4782 | require Linux::SysInfo;
|
|---|
| 4783 | Linux::SysInfo->import();
|
|---|
| 4784 | };
|
|---|
| 4785 | if ($@) {
|
|---|
| 4786 | # Linux::SysInfo not found
|
|---|
| 4787 | pb_log(1,"ADVISE: Install Linux::SysInfo to benefit from automatic parallelism optimization.\nOr optimize manually pbparallel in your pb.conf file\nUsing $pbparallel processes max at a time for the moment\nWARNING: This may consume too much memory for your system\n");
|
|---|
| 4788 | } else {
|
|---|
| 4789 | # Using the memory size
|
|---|
| 4790 | my $si = Linux::SysInfo::sysinfo();
|
|---|
| 4791 | if (not defined $si) {
|
|---|
| 4792 | pb_log(1,"ADVISE: Install Linux::SysInfo to benefit from automatic parallelism optimization.\nOr optimize manually pbparallel in your pb.conf file\nUsing $pbparallel processes max at a time for the moment\nWARNING: This may consume too much memory for your system\n");
|
|---|
| 4793 | } else {
|
|---|
| 4794 | # Keep the number of VM whose memory can be allocated
|
|---|
| 4795 | my $ram = $si->{"totalram"}-$si->{"sharedram"}-$si->{"bufferram"};
|
|---|
| 4796 | my $ram2;
|
|---|
| 4797 | my ($vmmem) = pb_conf_get_if("vmmem");
|
|---|
| 4798 |
|
|---|
| 4799 | my $v = "default";
|
|---|
| 4800 | if ((defined $vmmem) and (defined $vmmem->{$v})) {
|
|---|
| 4801 | $ram2 = $vmmem->{$v};
|
|---|
| 4802 | } else {
|
|---|
| 4803 | # Default for KVM/QEMU
|
|---|
| 4804 | $ram2 = 128;
|
|---|
| 4805 | }
|
|---|
| 4806 | $pbparallel = sprintf("%d",$ram/$ram2);
|
|---|
| 4807 | }
|
|---|
| 4808 | pb_log(1,"Using $pbparallel processes at a time\n");
|
|---|
| 4809 | }
|
|---|
| 4810 | }
|
|---|
| 4811 | pb_log(2,"pb_set_parallel returns: $pbparallel\n") if (defined $pbparallel);
|
|---|
| 4812 | return($pbparallel);
|
|---|
| 4813 | }
|
|---|
| 4814 |
|
|---|
| 4815 | sub pb_get_sudocmds {
|
|---|
| 4816 |
|
|---|
| 4817 | my $pbos = shift;
|
|---|
| 4818 | my @cmds = @_;
|
|---|
| 4819 | my %sudocmds;
|
|---|
| 4820 |
|
|---|
| 4821 | pb_log(2,"pb_get_sudocmds entering with lines:".Dumper(@cmds)."\n");
|
|---|
| 4822 | foreach my $c (split(/;/,$pbos->{'update'}),split(/;/,$pbos->{'install'}),@cmds) {
|
|---|
| 4823 | pb_log(2,"pb_get_sudocmds analyses $c\n");
|
|---|
| 4824 | next if ($c !~ /^\s*sudo/);
|
|---|
| 4825 | # remove sudo and leading spaces
|
|---|
| 4826 | $c =~ s/^\s*sudo\s+//;
|
|---|
| 4827 | # keep only the command, not the params
|
|---|
| 4828 | $c =~ s/([^\s]+)\s.*$/$1/;
|
|---|
| 4829 | $sudocmds{$c} = "";
|
|---|
| 4830 | }
|
|---|
| 4831 | pb_log(2,"pb_get_sudocmds returns ".Dumper(keys %sudocmds)."\n");
|
|---|
| 4832 | return(keys %sudocmds);
|
|---|
| 4833 | }
|
|---|
| 4834 |
|
|---|
| 4835 | sub pb_sign_pkgs {
|
|---|
| 4836 |
|
|---|
| 4837 | my $pbos = shift;
|
|---|
| 4838 | my $made = shift;
|
|---|
| 4839 |
|
|---|
| 4840 | pb_log(2,"entering pb_sign_pkg: $made ".Dumper($pbos)."\n");
|
|---|
| 4841 | my ($passfile, $passphrase, $passpath) = pb_conf_get_if("pbpassfile","pbpassphrase","pbpasspath");
|
|---|
| 4842 | $ENV{'PBPASSPHRASE'} = $passphrase->{$ENV{'PBPROJ'}} if ((not defined $ENV{'PBPASSPHRASE'}) && (defined $passphrase->{$ENV{'PBPROJ'}}));
|
|---|
| 4843 | $ENV{'PBPASSFILE'} = $passfile->{$ENV{'PBPROJ'}} if ((not defined $ENV{'PBPASSFILE'})&& (defined $passfile->{$ENV{'PBPROJ'}})) ;
|
|---|
| 4844 | $ENV{'PBPASSPATH'} = $passpath->{$ENV{'PBPROJ'}} if ((not defined $ENV{'PBPASSPATH'})&& (defined $passpath->{$ENV{'PBPROJ'}})) ;
|
|---|
| 4845 |
|
|---|
| 4846 | # Remove extra spaces
|
|---|
| 4847 | $made =~ s/\s+/ /g;
|
|---|
| 4848 | $made =~ s/^\s//g;
|
|---|
| 4849 | $made =~ s/\s$//g;
|
|---|
| 4850 |
|
|---|
| 4851 | if ($pbos->{'type'} eq "rpm") {
|
|---|
| 4852 | eval
|
|---|
| 4853 | {
|
|---|
| 4854 | require RPM4::Sign;
|
|---|
| 4855 | RPM4::Sign->import();
|
|---|
| 4856 | };
|
|---|
| 4857 | if ($@) {
|
|---|
| 4858 | # RPM4::Sign not found
|
|---|
| 4859 | pb_log(1,"WARNING: Install RPM4::Sign to benefit from automatic package signing.\n");
|
|---|
| 4860 | } else {
|
|---|
| 4861 | return if (((not defined $ENV{'PBPASSPHRASE'}) and (not defined $ENV{'PBPASSFILE'})) || (not defined $ENV{'PBPACKAGER'}) || (not defined $ENV{'PBPASSPATH'}));
|
|---|
| 4862 | my $sign = RPM4::Sign->new(
|
|---|
| 4863 | passphrase => $ENV{'PBPASSPHRASE'},
|
|---|
| 4864 | name => $ENV{'PBPACKAGER'},
|
|---|
| 4865 | path => $ENV{'PBPASSPATH'},
|
|---|
| 4866 | password_file => $ENV{'PBPASSFILE'},
|
|---|
| 4867 | );
|
|---|
| 4868 | return if (not defined $sign);
|
|---|
| 4869 | return if (not defined $sign->{name});
|
|---|
| 4870 | return if (not defined $sign->{path});
|
|---|
| 4871 | return if ((not defined $sign->{passphrase}) && (not defined $sign->{password_file}));
|
|---|
| 4872 | return if (not defined $sign->{keyid});
|
|---|
| 4873 |
|
|---|
| 4874 | pb_log(0,"Signing RPM packages...\n");
|
|---|
| 4875 | pb_log(2,"pb_sign_pkg: pkgs:".Dumper(split(/ /,$made))."\n");
|
|---|
| 4876 | $sign->rpmssign(split(/ /,$made));
|
|---|
| 4877 | }
|
|---|
| 4878 | } elsif ($pbos->{'type'} eq "deb") {
|
|---|
| 4879 | my $changes = "";
|
|---|
| 4880 | foreach my $c (split(/ /,$made)) {
|
|---|
| 4881 | $changes .= " $ENV{'PBBUILDDIR'}/$c" if (($c =~ /\.changes$/) && (-f "$ENV{PBBUILDDIR}/$c"));
|
|---|
| 4882 | }
|
|---|
| 4883 | my $debsigncmd = pb_check_req("debsign",1);
|
|---|
| 4884 | pb_system("$debsigncmd -m\'$ENV{'PBPACKAGER'}\' $changes","Signing DEB packages","mayfail") if (($changes ne "") && (defined $debsigncmd));
|
|---|
| 4885 | } else {
|
|---|
| 4886 | pb_log(0,"I don't know yet how to sign packages for type $pbos->{'type'}.\nPlease give feedback to dev team\n");
|
|---|
| 4887 | }
|
|---|
| 4888 | pb_log(2,"exiting pb_sign_pkg\n");
|
|---|
| 4889 | }
|
|---|
| 4890 |
|
|---|
| 4891 | # return list of all distributions supported, comma separated
|
|---|
| 4892 | sub pb_get_distros {
|
|---|
| 4893 |
|
|---|
| 4894 | my $pbos = shift;
|
|---|
| 4895 | my $pbtarget = shift;
|
|---|
| 4896 |
|
|---|
| 4897 | my @dists = ("$pbos->{'name'}-$pbos->{'version'}-$pbos->{'arch'}");
|
|---|
| 4898 |
|
|---|
| 4899 | # Get list of distributions for which we need to generate build files if no target
|
|---|
| 4900 | if (not defined $pbtarget) {
|
|---|
| 4901 | my @pt = pb_conf_get_if("vmlist","velist","rmlist");
|
|---|
| 4902 | foreach my $pt (@pt) {
|
|---|
| 4903 | push(@dists, split(/,/, $pt->{$ENV{PBPROJ}})) if defined $pt->{$ENV{PBPROJ}};
|
|---|
| 4904 | }
|
|---|
| 4905 | # remove any whitespace
|
|---|
| 4906 | grep(s/\s+//go, @dists);
|
|---|
| 4907 | }
|
|---|
| 4908 | return(join(",",@dists));
|
|---|
| 4909 | }
|
|---|
| 4910 |
|
|---|
| 4911 | sub pb_get_extdir {
|
|---|
| 4912 |
|
|---|
| 4913 | # the pbrc file should contain it and whatever the key, we take it
|
|---|
| 4914 | my ($ed) = pb_conf_read("$ENV{'PBDESTDIR'}/pbrc","pbextdir");
|
|---|
| 4915 | pb_log(2,"ed: ".Dumper($ed)."\n");
|
|---|
| 4916 | my $pbextdir = "";
|
|---|
| 4917 | foreach my $k (keys %$ed) {
|
|---|
| 4918 | $pbextdir = $ed->{$k};
|
|---|
| 4919 | # In case we have an empty field, empty it completely
|
|---|
| 4920 | pb_log(2,"pbextdir: ***$pbextdir***\n");
|
|---|
| 4921 | $pbextdir =~ s/^\s*$//;
|
|---|
| 4922 | }
|
|---|
| 4923 | pb_log(2,"pbextdir: ***$pbextdir***\n");
|
|---|
| 4924 | return($pbextdir);
|
|---|
| 4925 | }
|
|---|
| 4926 |
|
|---|
| 4927 | # Unused now
|
|---|
| 4928 | sub pb_keep_step {
|
|---|
| 4929 |
|
|---|
| 4930 | my $pbos = shift;
|
|---|
| 4931 | my $pbstep = shift;
|
|---|
| 4932 |
|
|---|
| 4933 | $pbstep = 3 if (not defined $pbstep);
|
|---|
| 4934 |
|
|---|
| 4935 | my %h;
|
|---|
| 4936 | my $h = \%h;
|
|---|
| 4937 | $h = pb_conf_cache("$ENV{'PBDESTDIR'}/$ENV{'PBPROJVER'}-$ENV{'PBPROJTAG'}.pb",$h);
|
|---|
| 4938 | $h->{'pbstep'}->{"$pbos->{'name'}-$pbos->{'version'}-$pbos->{'arch'}"} = $pbstep;
|
|---|
| 4939 | pb_conf_write("$ENV{'PBDESTDIR'}/$ENV{'PBPROJVER'}-$ENV{'PBPROJTAG'}.pb",$h);
|
|---|
| 4940 | }
|
|---|
| 4941 |
|
|---|
| 4942 | sub create_solaris_prototype {
|
|---|
| 4943 |
|
|---|
| 4944 | my $uidgid = "bin bin";
|
|---|
| 4945 | my $pkgdestdir = $ENV{'PBSOLDESTDIR'};
|
|---|
| 4946 |
|
|---|
| 4947 | return if ($_ =~ /^$pkgdestdir$/);
|
|---|
| 4948 | if (-d $_) {
|
|---|
| 4949 | my $n = $File::Find::name;
|
|---|
| 4950 | $n =~ s~$pkgdestdir/~~;
|
|---|
| 4951 | print PROTO "d none $n 0755 $uidgid\n";
|
|---|
| 4952 | } elsif (-x $_) {
|
|---|
| 4953 | my $n = $File::Find::name;
|
|---|
| 4954 | $n =~ s~$pkgdestdir/~~;
|
|---|
| 4955 | print PROTO "f none $n 0755 $uidgid\n";
|
|---|
| 4956 | } elsif (-f $_) {
|
|---|
| 4957 | my $n = $File::Find::name;
|
|---|
| 4958 | $n =~ s~$pkgdestdir/~~;
|
|---|
| 4959 | print PROTO "f none $n 0644 $uidgid\n";
|
|---|
| 4960 | }
|
|---|
| 4961 | }
|
|---|
| 4962 |
|
|---|
| 4963 | sub pb_ssh_setup {
|
|---|
| 4964 |
|
|---|
| 4965 | my $vtype = shift;
|
|---|
| 4966 | my $nport = shift;
|
|---|
| 4967 |
|
|---|
| 4968 | my $keyfile;
|
|---|
| 4969 | my $vmhost;
|
|---|
| 4970 |
|
|---|
| 4971 | pb_log(1,"Entering pb_ssh_setup\n");
|
|---|
| 4972 | ($vmhost) = pb_conf_get($vtype."host");
|
|---|
| 4973 | # Prepare the key to be used and transfered remotely
|
|---|
| 4974 | $keyfile = pb_ssh_get(1,$vmhost->{$ENV{'PBPROJ'}},$nport);
|
|---|
| 4975 | return if (not defined $keyfile);
|
|---|
| 4976 |
|
|---|
| 4977 | # We call true to avoid problems if SELinux is not activated, but chcon is present and returns in that case 1
|
|---|
| 4978 | pb_system("cat $keyfile.pub | ssh -q -o UserKnownHostsFile=/dev/null -p $nport -i $keyfile root\@$vmhost->{$ENV{'PBPROJ'}} \"mkdir -p .ssh ; chmod 700 .ssh ; cat >> .ssh/authorized_keys ; chmod 600 .ssh/authorized_keys ; if [ -x /usr/bin/chcon ]; then /usr/bin/chcon -Rt home_ssh_t .ssh 2> /dev/null; /bin/true; fi\"","Copying local keys to $vtype. This may require the root password");
|
|---|
| 4979 | # once this is done, we can do what we need on the VM/RM remotely
|
|---|
| 4980 |
|
|---|
| 4981 | # in particular we can remove duplicate in .ssh/authorized_keys of our key if needed
|
|---|
| 4982 | # Store the pub key part in a variable
|
|---|
| 4983 | open(FILE,"$keyfile.pub") || die "Unable to open $keyfile.pub";
|
|---|
| 4984 | my ($zero0,$zero1,$zero2) = split(/ /,<FILE>);
|
|---|
| 4985 | close(FILE);
|
|---|
| 4986 | my $key = "\Q$zero1";
|
|---|
| 4987 | my $perls = "$ENV{'PBTMP'}/perls.$$";
|
|---|
| 4988 |
|
|---|
| 4989 | open(FILE,"> $perls") || die "Unable to open $perls";
|
|---|
| 4990 | print FILE << 'EOF';
|
|---|
| 4991 | my $file1="$ENV{'HOME'}/.ssh/authorized_keys";
|
|---|
| 4992 | open(PBFILE,$file1) || die "Unable to open $file1";
|
|---|
| 4993 | open(PBOUT,"> $file1.new") || die "Unable to open $file1.new";
|
|---|
| 4994 | my $count = 0;
|
|---|
| 4995 | while (<PBFILE>) {
|
|---|
| 4996 | EOF
|
|---|
| 4997 | print FILE << "EOF";
|
|---|
| 4998 | if (/ $key /) {
|
|---|
| 4999 | \$count++;
|
|---|
| 5000 | }
|
|---|
| 5001 | print PBOUT \$_ if ((\$count <= 1) || (\$_ !~ / $key /));
|
|---|
| 5002 | }
|
|---|
| 5003 | close(PBFILE);
|
|---|
| 5004 | close(PBOUT);
|
|---|
| 5005 | rename("\$file1.new",\$file1);
|
|---|
| 5006 | chmod 0600,\$file1;
|
|---|
| 5007 | EOF
|
|---|
| 5008 | close(FILE);
|
|---|
| 5009 | pb_system("cat $perls | ssh -q -o UserKnownHostsFile=/dev/null -p $nport -i $keyfile root\@$vmhost->{$ENV{'PBPROJ'}} perl","","quiet");
|
|---|
| 5010 | return;
|
|---|
| 5011 | }
|
|---|
| 5012 |
|
|---|
| 5013 | 1;
|
|---|
