1 /************************************************************************* 2 * 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * Copyright 2000, 2010 Oracle and/or its affiliates. 6 * 7 * OpenOffice.org - a multi-platform office productivity suite 8 * 9 * This file is part of OpenOffice.org. 10 * 11 * OpenOffice.org is free software: you can redistribute it and/or modify 12 * it under the terms of the GNU Lesser General Public License version 3 13 * only, as published by the Free Software Foundation. 14 * 15 * OpenOffice.org is distributed in the hope that it will be useful, 16 * but WITHOUT ANY WARRANTY; without even the implied warranty of 17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 18 * GNU Lesser General Public License version 3 for more details 19 * (a copy is included in the LICENSE file that accompanied this code). 20 * 21 * You should have received a copy of the GNU Lesser General Public License 22 * version 3 along with OpenOffice.org. If not, see 23 * <http://www.openoffice.org/license.html> 24 * for a copy of the LGPLv3 License. 25 * 26 ************************************************************************/ 27 28 package org.openoffice.setup.Installer; 29 30 import java.io.File; 31 import org.openoffice.setup.InstallData; 32 import org.openoffice.setup.InstallerHelper.LinuxHelper; 33 import org.openoffice.setup.ResourceManager; 34 import org.openoffice.setup.SetupData.PackageDescription; 35 import org.openoffice.setup.SetupData.ProductDescription; 36 import org.openoffice.setup.SetupData.SetupDataProvider; 37 import org.openoffice.setup.Util.ExecuteProcess; 38 import org.openoffice.setup.Util.Informer; 39 import org.openoffice.setup.Util.LogManager; 40 import java.util.HashMap; 41 import java.util.Iterator; 42 import java.util.Map; 43 import java.util.Vector; 44 45 public class LinuxInstaller extends Installer { 46 47 LinuxHelper helper = new LinuxHelper(); 48 49 public LinuxInstaller() { 50 super(); 51 } 52 53 public void preInstall(PackageDescription packageData) { 54 InstallData installData = InstallData.getInstance(); 55 // Collecting package names 56 helper.getLinuxPackageNamesFromRpmquery(packageData, installData); 57 helper.getLinuxFileInfo(packageData); 58 // Dumper.dumpAllRpmInfo(packageData); 59 } 60 61 public void postInstall(PackageDescription packageData) { 62 InstallData data = InstallData.getInstance(); 63 64 if ( ! data.isAbortedInstallation() ) { 65 data.setStillRunning(true); 66 // Collecting information about installed packages 67 // Creating a list containing pairs of package names and rpm file names 68 // that has to be used during uninstallation. 69 helper.createPackageNameFileAtPostinstall(data, packageData); 70 helper.saveModulesLogFile(data); 71 data.setStillRunning(false); 72 } 73 } 74 75 public void preUninstall(PackageDescription packageData) { 76 // Collecting information about installed packages 77 HashMap packageNames = helper.readPackageNamesFile(); 78 helper.setFullPackageNameAtUninstall(packageData, packageNames); 79 helper.getLinuxFileInfo(packageData); 80 // Dumper.dumpAllRpmInfo(packageData); 81 } 82 83 public void defineDatabasePath() { 84 85 InstallData data = InstallData.getInstance(); 86 String oldDatabasePath = data.getDatabasePath(); 87 data.setDatabasePath(null); 88 89 // Determining the database path (only for user installation). 90 // Important if a user installation is done into an existing 91 // user installation -> this methode can only be called after 92 // determination of installation directory. 93 94 if ( data.isUserInstallation() ) { 95 String databasePath = helper.getLinuxDatabasePath(data); // the file does not need to exist! 96 data.setDatabasePath(databasePath); 97 98 // If this is a new path to the database, then this database was 99 // not analyzed before (when going back in installation wizard) 100 if ( ! databasePath.equals(oldDatabasePath) ) { 101 data.setDatabaseAnalyzed(false); 102 data.setDatabaseQueried(false); 103 } 104 } 105 } 106 107 public String getChangeInstallDir(PackageDescription packageData) { 108 String installDir = null; 109 InstallData installData = InstallData.getInstance(); 110 111 String packageName = packageData.getPkgRealName(); 112 113 if ( packageName != null ) { 114 String rpmCommand = "rpm -q --queryformat %{INSTALLPREFIX} " + packageName; 115 String[] rpmCommandArray = new String[5]; 116 rpmCommandArray[0] = "rpm"; 117 rpmCommandArray[1] = "-q"; 118 rpmCommandArray[2] = "--queryformat"; 119 rpmCommandArray[3] = "%{INSTALLPREFIX}"; 120 rpmCommandArray[4] = packageName; 121 122 Vector returnVector = new Vector(); 123 Vector returnErrorVector = new Vector(); 124 int returnValue = ExecuteProcess.executeProcessReturnVector(rpmCommandArray, returnVector, returnErrorVector); 125 String returnString = (String) returnVector.get(0); 126 returnString = returnString.replaceAll("//","/"); 127 128 String log = rpmCommand + "<br><b>Returns: " + returnString + "</b><br>"; 129 LogManager.addCommandsLogfileComment(log); 130 131 installDir = returnString; 132 } 133 134 return installDir; 135 } 136 137 public void installPackage(PackageDescription packageData) { 138 // get ProductDescription for logging mechanism 139 ProductDescription productData = SetupDataProvider.getProductDescription(); 140 InstallData data = InstallData.getInstance(); 141 142 // String log = "<br><b>Package: " + packageData.getName() + "</b>"; 143 // LogManager.addCommandsLogfileComment(log); 144 String log = ""; 145 146 // setting installDir 147 String installDir = data.getInstallDir(); 148 String packagePath = data.getPackagePath(); 149 150 if (( packageData.getPkgSubdir() != null ) && ( ! packageData.getPkgSubdir().equals("") )) { 151 File completePackageFile = new File(packagePath, packageData.getPkgSubdir()); 152 packagePath = completePackageFile.getPath(); 153 } 154 155 String packageName = packageData.getPackageName(); 156 157 if (( packageName.equals("")) || ( packageName == null )) { 158 log = "<b>No package name specified. Nothing to do</b>"; 159 LogManager.addCommandsLogfileComment(log); 160 } else { 161 log = "<b>Package Name: " + packageName + "</b>"; 162 LogManager.addCommandsLogfileComment(log); 163 164 File completePackage = new File(packagePath, packageName); 165 packageName = completePackage.getPath(); 166 packageName = "\"" + packageName + "\""; // Quoting is necessary, if the path the the packages contains white spaces. 167 168 if ( completePackage.exists() ) { 169 String relocations = helper.getRelocationString(packageData, packageName); 170 if ( relocations != null ) { 171 // Problem: If Prefix = "/" the packages are not relocatable with RPM version 3.x . 172 // Therefore Prefix has to be "/opt" in spec file, although packages shall not be 173 // relocatable (except for installations with root privileges). So /opt has to be 174 // listed left and right of equal sign: --relocate /opt=<installDir>/opt 175 // -> /opt has to be added to the installDir 176 File localInstallDir = new File(installDir, relocations); // "/" -> "/opt" 177 String localInstallDirString = localInstallDir.getPath(); 178 179 // Fixing problem with installation directory and RPM version 3.x 180 String fixedInstallDir = helper.fixInstallationDirectory(localInstallDirString); 181 relocations = relocations + "=" + fixedInstallDir; 182 // relocations: "/opt/staroffice8=" + fixedInstallDir; 183 } 184 185 // Some packages have to be installed with parameter "--force", if the link "/usr/bin/soffice" 186 // already exists. These pacakges return true with methode "useForce()". 187 boolean useForce = false; 188 if ( packageData.useForce() ) { 189 File sofficeLink = new File("/usr/bin/soffice"); 190 if ( sofficeLink.exists() ) { useForce = true; } 191 } 192 193 // On Debian based systems, rpms can be installed with the switch --force-debian, if a rpm 194 // is installed. 195 196 String forceDebianString = ""; 197 String nodepsString = ""; 198 199 if ( ! data.debianInvestigated() ) { 200 helper.investigateDebian(data); 201 data.setDebianInvestigated(true); 202 } 203 204 if ( data.isDebianSystem() ) { 205 nodepsString = "--nodeps"; 206 207 if ( data.useForceDebian() ) { 208 forceDebianString = "--force-debian"; 209 } 210 } 211 212 String databasePath = null; 213 String databaseString = ""; 214 boolean useLocalDatabase = false; 215 216 if ( data.isUserInstallation() ) { 217 databasePath = data.getDatabasePath(); 218 if ( databasePath == null ) { 219 databasePath = helper.getLinuxDatabasePath(data); 220 data.setDatabasePath(databasePath); 221 } 222 } 223 224 if (( databasePath != null ) && (! databasePath.equalsIgnoreCase("null"))) { 225 databaseString = "--dbpath"; 226 useLocalDatabase = true; 227 } 228 229 // Defining a Vector that contains the full rpm command. Then the string array can be 230 // created dynamically. Otherwise there would be too many different scenarios. 231 232 Vector rpmVector = new Vector(); 233 234 rpmVector.add("rpm"); 235 rpmVector.add("--upgrade"); 236 rpmVector.add("--ignoresize"); 237 238 if ( useForce ) { 239 rpmVector.add("--force"); 240 } 241 242 if ( ! forceDebianString.equals("") ) { 243 rpmVector.add(forceDebianString); 244 } 245 246 if ( ! nodepsString.equals("") ) { 247 rpmVector.add(nodepsString); 248 } 249 250 rpmVector.add("-vh"); 251 252 if ( relocations != null ) { 253 rpmVector.add("--relocate"); 254 rpmVector.add(relocations); 255 } 256 257 if ( useLocalDatabase ) { 258 rpmVector.add(databaseString); 259 rpmVector.add(databasePath); 260 } 261 262 rpmVector.add(packageName); 263 264 // Creating String and StringArray for rpm command 265 266 int capacity = rpmVector.size(); 267 268 String rpmCommand = ""; 269 String[] rpmCommandArray = new String[capacity]; 270 271 for (int i = 0; i < rpmVector.size(); i++) { 272 rpmCommandArray[i] = (String)rpmVector.get(i); 273 rpmCommand = rpmCommand + " " + (String)rpmVector.get(i); 274 } 275 276 rpmCommand = rpmCommand.trim(); 277 278 // Staring rpm process 279 280 Vector returnVector = new Vector(); 281 Vector returnErrorVector = new Vector(); 282 // int returnValue = SystemManager.executeProcessReturnVector(rpmCommand, returnVector, returnErrorVector); 283 int returnValue = ExecuteProcess.executeProcessReturnVector(rpmCommandArray, returnVector, returnErrorVector); 284 285 if ( returnValue == 0 ) { 286 log = rpmCommand + "<br><b>Returns: " + returnValue + " Successful installation</b><br>"; 287 LogManager.addCommandsLogfileComment(log); 288 } else { // an error occured during installation 289 if ( packageData.installCanFail() ) { 290 log = rpmCommand + "<br><b>Returns: " + returnValue + " Problem during installation. Can be ignored.</b><br>"; 291 LogManager.addCommandsLogfileComment(log); 292 } else { 293 log = rpmCommand + "<br><b>Returns: " + returnValue + " Error during installation</b><br>"; 294 LogManager.addCommandsLogfileComment(log); 295 for (int i = 0; i < returnErrorVector.size(); i++) { 296 LogManager.addCommandsLogfileComment((String)returnErrorVector.get(i)); 297 } 298 data.setIsErrorInstallation(true); 299 } 300 } 301 302 // saving installation state at package 303 packageData.setIsNewInstalled(true); 304 } else { 305 log = "<b>Error: Did not find package " + packageName + "</b><br>"; 306 System.err.println(log); 307 String message = ResourceManager.getString("String_File_Not_Found") + ": " + packageName; 308 String title = ResourceManager.getString("String_Error"); 309 Informer.showErrorMessage(message, title); 310 LogManager.addCommandsLogfileComment(log); 311 data.setIsErrorInstallation(true); 312 } 313 } 314 } 315 316 public void uninstallPackage(PackageDescription packageData) { 317 // get ProductDescription for logging mechanism 318 ProductDescription productData = SetupDataProvider.getProductDescription(); 319 InstallData data = InstallData.getInstance(); 320 321 String log = ""; 322 // String log = "<br><b>Package: " + packageData.getName() + "</b>"; 323 // LogManager.addCommandsLogfileComment(log); 324 325 String rpmPackageName = packageData.getPackageName(); 326 327 if (( rpmPackageName.equals("")) || ( rpmPackageName == null )) { 328 log = "<b>No package name specified. Nothing to do</b>"; 329 LogManager.addCommandsLogfileComment(log); 330 } else { 331 log = "<b>Package Name: " + rpmPackageName + "</b>"; 332 LogManager.addCommandsLogfileComment(log); 333 334 String packageName = packageData.getPkgRealName(); 335 String databasePath = data.getDatabasePath(); 336 String databaseString = ""; 337 boolean useLocalDatabase = false; 338 339 if (( databasePath != null ) && (! databasePath.equalsIgnoreCase("null"))) { 340 databaseString = "--dbpath"; 341 useLocalDatabase = true; 342 } 343 344 // On Debian based systems, rpms can be installed with the switch --force-debian, if a rpm 345 // is installed. 346 347 String forceDebianString = ""; 348 String nodepsString = ""; 349 String noscriptsString = ""; 350 351 if ( ! data.debianInvestigated() ) { 352 helper.investigateDebian(data); 353 data.setDebianInvestigated(true); 354 } 355 356 if ( data.isDebianSystem() ) { 357 nodepsString = "--nodeps"; 358 359 if ( data.useForceDebian() ) { 360 forceDebianString = "--force-debian"; 361 } 362 } 363 364 if (( data.isErrorInstallation() ) && ( data.isFirstPackage() )) { 365 noscriptsString = "--noscripts"; 366 } 367 368 // Defining a Vector that contains the full rpm command. Then the string array can be 369 // created dynamically. Otherwise there would be too many different scenarios. 370 371 Vector rpmVector = new Vector(); 372 373 rpmVector.add("rpm"); 374 375 if ( ! forceDebianString.equals("") ) { 376 rpmVector.add(forceDebianString); 377 } 378 379 if ( ! nodepsString.equals("") ) { 380 rpmVector.add(nodepsString); 381 } 382 383 if ( ! noscriptsString.equals("") ) { 384 rpmVector.add(noscriptsString); 385 } 386 387 rpmVector.add("-ev"); 388 389 if ( useLocalDatabase ) { 390 rpmVector.add(databaseString); 391 rpmVector.add(databasePath); 392 } 393 394 rpmVector.add(packageName); 395 396 // Creating String and StringArray for rpm command 397 398 int capacity = rpmVector.size(); 399 400 String rpmCommand = ""; 401 String[] rpmCommandArray = new String[capacity]; 402 403 for (int i = 0; i < rpmVector.size(); i++) { 404 rpmCommandArray[i] = (String)rpmVector.get(i); 405 rpmCommand = rpmCommand + " " + (String)rpmVector.get(i); 406 } 407 408 rpmCommand = rpmCommand.trim(); 409 410 // Starting rpm process 411 412 Vector returnVector = new Vector(); 413 Vector returnErrorVector = new Vector(); 414 int returnValue = ExecuteProcess.executeProcessReturnVector(rpmCommandArray, returnVector, returnErrorVector); 415 416 if ( returnValue == 0 ) { 417 log = rpmCommand + "<br><b>Returns: " + returnValue + " Successful uninstallation</b><br>"; 418 LogManager.addCommandsLogfileComment(log); 419 } else { // an error occured during installation 420 if ( packageData.uninstallCanFail() ) { 421 log = rpmCommand + "<br><b>Returns: " + returnValue + " Problem during uninstallation. Can be ignored.</b><br>"; 422 LogManager.addCommandsLogfileComment(log); 423 } else { 424 log = rpmCommand + "<br><b>Returns: " + returnValue + " Error during uninstallation</b><br>"; 425 LogManager.addCommandsLogfileComment(log); 426 for (int i = 0; i < returnErrorVector.size(); i++) { 427 LogManager.addCommandsLogfileComment((String)returnErrorVector.get(i)); 428 } 429 data.setIsErrorInstallation(true); 430 } 431 } 432 } 433 } 434 435 public boolean isPackageInstalledClassic(PackageDescription packageData, InstallData installData) { 436 437 boolean isInstalled = false; 438 boolean doCheck = false; 439 440 // only checking existing packages (and always at uninstallation) 441 if ( (packageData.pkgExists()) || (installData.isUninstallationMode()) ) { 442 doCheck = true; 443 } 444 445 String rpmPackageName = packageData.getPackageName(); 446 447 if ( rpmPackageName.equals("") ) { 448 rpmPackageName = null; 449 } 450 451 if (( rpmPackageName != null ) && ( doCheck )) { 452 453 String databaseString = ""; 454 String databasePath = null; 455 String packageName = packageData.getPkgRealName(); 456 Vector allPackages = null; 457 boolean useLocalDatabase = false; 458 459 if (installData.isUserInstallation()) { 460 databasePath = installData.getDatabasePath(); 461 } 462 463 if (( databasePath != null ) && (! databasePath.equals("null"))) { 464 databaseString = "--dbpath"; 465 useLocalDatabase = true; 466 } 467 468 if (packageName != null) { 469 470 String rpmCommand; 471 String[] rpmCommandArray; 472 473 if (useLocalDatabase) { 474 rpmCommand = "rpm" + " " + databaseString + " " + databasePath + " --query " + packageName; 475 rpmCommandArray = new String[5]; 476 rpmCommandArray[0] = "rpm"; 477 rpmCommandArray[1] = databaseString; 478 rpmCommandArray[2] = databasePath; 479 rpmCommandArray[3] = "--query"; 480 rpmCommandArray[4] = packageName; 481 } else { 482 rpmCommand = "rpm" + " --query " + packageName; 483 rpmCommandArray = new String[3]; 484 rpmCommandArray[0] = "rpm"; 485 rpmCommandArray[1] = "--query"; 486 rpmCommandArray[2] = packageName; 487 } 488 489 int returnValue = ExecuteProcess.executeProcessReturnValue(rpmCommandArray); 490 491 if ( returnValue == 0 ) { 492 isInstalled = true; 493 packageData.setWasAlreadyInstalled(true); // needed for logging 494 String log = rpmCommand + "<br><b>Returns: " + returnValue + " Package is installed" + "</b><br>"; 495 LogManager.addCommandsLogfileComment(log); 496 } else { 497 String log = rpmCommand + "<br><b>Returns: " + returnValue + " Package is not installed" + "</b><br>"; 498 LogManager.addCommandsLogfileComment(log); 499 } 500 } 501 } 502 503 return isInstalled; 504 } 505 506 private void queryAllDatabase(InstallData installData) { 507 508 String databaseString = ""; 509 String databasePath = null; 510 HashMap map = new HashMap();; 511 boolean useLocalDatabase = false; 512 513 if (installData.isUserInstallation()) { 514 databasePath = installData.getDatabasePath(); 515 } 516 517 if (( databasePath != null ) && (! databasePath.equals("null"))) { 518 databaseString = "--dbpath"; 519 useLocalDatabase = true; 520 } 521 522 String rpmCommand; 523 String[] rpmCommandArray; 524 525 if (useLocalDatabase) { 526 rpmCommand = "rpm" + " " + databaseString + " " + databasePath + " --query" + " -a"; 527 rpmCommandArray = new String[5]; 528 rpmCommandArray[0] = "rpm"; 529 rpmCommandArray[1] = databaseString; 530 rpmCommandArray[2] = databasePath; 531 rpmCommandArray[3] = "--query"; 532 rpmCommandArray[4] = "-a"; 533 } else { 534 rpmCommand = "rpm" + " --query" + " -a"; 535 rpmCommandArray = new String[3]; 536 rpmCommandArray[0] = "rpm"; 537 rpmCommandArray[1] = "--query"; 538 rpmCommandArray[2] = "-a"; 539 } 540 541 Vector returnVector = new Vector(); 542 Vector returnErrorVector = new Vector(); 543 int returnValue = ExecuteProcess.executeProcessReturnVector(rpmCommandArray, returnVector, returnErrorVector); 544 545 String log = rpmCommand + "<br><b>Returns: " + returnValue + "</b><br>"; 546 LogManager.addCommandsLogfileComment(log); 547 String value = "1"; 548 549 if ( ! returnVector.isEmpty()) { 550 for (int i = 0; i < returnVector.size(); i++) { 551 String onePackage = (String)returnVector.get(i); 552 int pos1 = onePackage.lastIndexOf("-"); 553 int pos2 = onePackage.substring(0, pos1).lastIndexOf("-"); 554 String key = onePackage.substring(0, pos2); 555 map.put(key, value); 556 } 557 } 558 559 installData.setDatabaseQueried(true); 560 installData.setDatabaseMap(map); 561 } 562 563 public boolean isPackageInstalled(PackageDescription packageData, InstallData installData) { 564 565 boolean isInstalled = false; 566 boolean doCheck = false; 567 568 // only checking existing packages (and always at uninstallation) 569 if ( (packageData.pkgExists()) || (installData.isUninstallationMode()) ) { 570 doCheck = true; 571 } 572 573 String rpmPackageName = packageData.getPackageName(); 574 575 if ( rpmPackageName.equals("") ) { 576 rpmPackageName = null; 577 } 578 579 if (( rpmPackageName != null ) && ( doCheck )) { 580 String packageName = packageData.getPkgRealName(); 581 582 if (packageName != null) { 583 584 HashMap map = null; 585 if ( ! installData.databaseQueried() ) { 586 queryAllDatabase(installData); 587 } 588 589 map = installData.getDatabaseMap(); 590 591 if ( map.containsKey(packageName)) { 592 isInstalled = true; 593 } 594 } else { 595 System.err.println("Error: No packageName defined for package: " + packageData.getPackageName()); 596 } 597 } 598 599 return isInstalled; 600 } 601 602 public boolean isInstallSetPackageOlder(PackageDescription packageData, InstallData installData) { 603 boolean installSetPackageIsOlder = false; 604 boolean checkIfInstalledIsOlder = false; 605 installSetPackageIsOlder = findOlderPackage(packageData, installData, checkIfInstalledIsOlder); 606 return installSetPackageIsOlder; 607 } 608 609 public boolean isInstalledPackageOlder(PackageDescription packageData, InstallData installData) { 610 boolean installedPackageIsOlder = false; 611 boolean checkIfInstalledIsOlder = true; 612 installedPackageIsOlder = findOlderPackage(packageData, installData, checkIfInstalledIsOlder); 613 return installedPackageIsOlder; 614 } 615 616 private boolean findOlderPackage(PackageDescription packageData, InstallData installData, boolean checkIfInstalledIsOlder) { 617 618 // The information about the new package is stored in packageData (the version and the release). 619 // This information can be stored in xpd files. If it is not stored in xpd files, it is determined 620 // during installation process by querying the rpm file. This process costs much time and should 621 // therefore be done by the process, that creates the xpd files. On the other hand this requires, 622 // that the xpd files contain the correct information. 623 624 boolean isOlder = false; 625 626 // get the version of the installed package 627 String rpmPackageName = packageData.getPackageName(); 628 String log; 629 630 if ( rpmPackageName.equals("")) { 631 rpmPackageName = null; 632 } 633 634 if ( rpmPackageName != null ) { 635 String databaseString = ""; 636 String databasePath = null; 637 String packageName = packageData.getPkgRealName(); 638 Vector allPackages = null; 639 boolean useLocalDatabase = false; 640 641 if (installData.isUserInstallation()) { 642 databasePath = installData.getDatabasePath(); 643 } 644 645 if (( databasePath != null ) && (! databasePath.equals("null"))) { 646 databaseString = "--dbpath"; 647 useLocalDatabase = true; 648 } 649 650 if (packageName != null) { 651 // Collect information about the installed package by querying the database. 652 // Instead of rpm file name, the real package name has to be used. 653 654 String rpmCommand; 655 String[] rpmCommandArray; 656 657 if (useLocalDatabase) { 658 rpmCommand = "rpm" + " " + databaseString + " " + databasePath + " -q --queryformat %{VERSION}\\n " + packageName; 659 rpmCommandArray = new String[7]; 660 rpmCommandArray[0] = "rpm"; 661 rpmCommandArray[1] = databaseString; 662 rpmCommandArray[2] = databasePath; 663 rpmCommandArray[3] = "-q"; 664 rpmCommandArray[4] = "--queryformat"; 665 rpmCommandArray[5] = "%{VERSION}\\n"; 666 rpmCommandArray[6] = packageName; 667 } else { 668 rpmCommand = "rpm" + " -q --queryformat %{VERSION}\\n " + packageName; 669 rpmCommandArray = new String[5]; 670 rpmCommandArray[0] = "rpm"; 671 rpmCommandArray[1] = "-q"; 672 rpmCommandArray[2] = "--queryformat"; 673 rpmCommandArray[3] = "%{VERSION}\\n"; 674 rpmCommandArray[4] = packageName; 675 } 676 677 Vector versionVector = new Vector(); 678 Vector returnErrorVector = new Vector(); 679 int returnValue = ExecuteProcess.executeProcessReturnVector(rpmCommandArray, versionVector, returnErrorVector); 680 String version = (String) versionVector.lastElement(); 681 log = rpmCommand + "<br><b>Returns: " + version + "</b><br>"; 682 LogManager.addCommandsLogfileComment(log); 683 684 if ( ! installData.installedProductMinorSet() ) { 685 int productMinor = helper.getInstalledMinor(version); 686 installData.setInstalledProductMinor(productMinor); 687 installData.setInstalledProductMinorSet(true); 688 } 689 690 if (useLocalDatabase) { 691 rpmCommand = "rpm" + " " + databaseString + " " + databasePath + " -q --queryformat %{RELEASE}\\n " + packageName; 692 rpmCommandArray[5] = "%{RELEASE}\\n"; 693 } else { 694 rpmCommand = "rpm" + " -q --queryformat %{RELEASE}\\n " + packageName; 695 rpmCommandArray[3] = "%{RELEASE}\\n"; 696 } 697 698 Vector releaseVector = new Vector(); 699 returnValue = ExecuteProcess.executeProcessReturnVector(rpmCommandArray, releaseVector, returnErrorVector); 700 String release = (String) releaseVector.lastElement(); 701 702 log = rpmCommand + "<br><b>Returns: " + release + "</b><br>"; 703 LogManager.addCommandsLogfileComment(log); 704 705 isOlder = helper.compareVersionAndRelease(version, release, packageData, checkIfInstalledIsOlder); 706 707 if ( checkIfInstalledIsOlder ) { 708 if ( isOlder ) { 709 LogManager.addCommandsLogfileComment("<b>-> Installed package is older</b><br>"); 710 } else { 711 LogManager.addCommandsLogfileComment("<b>-> Installed package is not older</b><br>"); 712 } 713 } else { 714 if ( isOlder ) { 715 LogManager.addCommandsLogfileComment("<b>-> Package in installation set is older</b><br>"); 716 } else { 717 LogManager.addCommandsLogfileComment("<b>-> Package in installation set is not older</b><br>"); 718 } 719 } 720 721 } else { 722 System.err.println("Error: No packageName defined for package: " + rpmPackageName); 723 } 724 } 725 726 return isOlder; 727 } 728 729 } 730