|
[ source navigation ] [ diff markup ] [ identifier search ] [ general search ] |
|||||
|
||||||
001 /************************************************************************* 002 * 003 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 004 * 005 * Copyright 2008 by Sun Microsystems, Inc. 006 * 007 * OpenOffice.org - a multi-platform office productivity suite 008 * 009 * $RCSfile: LinuxInstaller.java,v $ 010 * $Revision: 1.7 $ 011 * 012 * This file is part of OpenOffice.org. 013 * 014 * OpenOffice.org is free software: you can redistribute it and/or modify 015 * it under the terms of the GNU Lesser General Public License version 3 016 * only, as published by the Free Software Foundation. 017 * 018 * OpenOffice.org is distributed in the hope that it will be useful, 019 * but WITHOUT ANY WARRANTY; without even the implied warranty of 020 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 021 * GNU Lesser General Public License version 3 for more details 022 * (a copy is included in the LICENSE file that accompanied this code). 023 * 024 * You should have received a copy of the GNU Lesser General Public License 025 * version 3 along with OpenOffice.org. If not, see 026 * <http://www.openoffice.org/license.html> 027 * for a copy of the LGPLv3 License. 028 * 029 ************************************************************************/ 030 031 package org.openoffice.setup.Installer; 032 033 import java.io.File; 034 import org.openoffice.setup.InstallData; 035 import org.openoffice.setup.InstallerHelper.LinuxHelper; 036 import org.openoffice.setup.ResourceManager; 037 import org.openoffice.setup.SetupData.PackageDescription; 038 import org.openoffice.setup.SetupData.ProductDescription; 039 import org.openoffice.setup.SetupData.SetupDataProvider; 040 import org.openoffice.setup.Util.ExecuteProcess; 041 import org.openoffice.setup.Util.Informer; 042 import org.openoffice.setup.Util.LogManager; 043 import java.util.HashMap; 044 import java.util.Iterator; 045 import java.util.Map; 046 import java.util.Vector; 047 048 public class LinuxInstaller extends Installer { 049 050 LinuxHelper helper = new LinuxHelper(); 051 052 public LinuxInstaller() { 053 super(); 054 } 055 056 public void preInstall(PackageDescription packageData) { 057 InstallData installData = InstallData.getInstance(); 058 // Collecting package names 059 helper.getLinuxPackageNamesFromRpmquery(packageData, installData); 060 helper.getLinuxFileInfo(packageData); 061 // Dumper.dumpAllRpmInfo(packageData); 062 } 063 064 public void postInstall(PackageDescription packageData) { 065 InstallData data = InstallData.getInstance(); 066 067 if ( ! data.isAbortedInstallation() ) { 068 data.setStillRunning(true); 069 // Collecting information about installed packages 070 // Creating a list containing pairs of package names and rpm file names 071 // that has to be used during uninstallation. 072 helper.createPackageNameFileAtPostinstall(data, packageData); 073 helper.saveModulesLogFile(data); 074 data.setStillRunning(false); 075 } 076 } 077 078 public void preUninstall(PackageDescription packageData) { 079 // Collecting information about installed packages 080 HashMap packageNames = helper.readPackageNamesFile(); 081 helper.setFullPackageNameAtUninstall(packageData, packageNames); 082 helper.getLinuxFileInfo(packageData); 083 // Dumper.dumpAllRpmInfo(packageData); 084 } 085 086 public void defineDatabasePath() { 087 088 InstallData data = InstallData.getInstance(); 089 String oldDatabasePath = data.getDatabasePath(); 090 data.setDatabasePath(null); 091 092 // Determining the database path (only for user installation). 093 // Important if a user installation is done into an existing 094 // user installation -> this methode can only be called after 095 // determination of installation directory. 096 097 if ( data.isUserInstallation() ) { 098 String databasePath = helper.getLinuxDatabasePath(data); // the file does not need to exist! 099 data.setDatabasePath(databasePath); 100 101 // If this is a new path to the database, then this database was 102 // not analyzed before (when going back in installation wizard) 103 if ( ! databasePath.equals(oldDatabasePath) ) { 104 data.setDatabaseAnalyzed(false); 105 data.setDatabaseQueried(false); 106 } 107 } 108 } 109 110 public String getChangeInstallDir(PackageDescription packageData) { 111 String installDir = null; 112 InstallData installData = InstallData.getInstance(); 113 114 String packageName = packageData.getPkgRealName(); 115 116 if ( packageName != null ) { 117 String rpmCommand = "rpm -q --queryformat %{INSTALLPREFIX} " + packageName; 118 String[] rpmCommandArray = new String[5]; 119 rpmCommandArray[0] = "rpm"; 120 rpmCommandArray[1] = "-q"; 121 rpmCommandArray[2] = "--queryformat"; 122 rpmCommandArray[3] = "%{INSTALLPREFIX}"; 123 rpmCommandArray[4] = packageName; 124 125 Vector returnVector = new Vector(); 126 Vector returnErrorVector = new Vector(); 127 int returnValue = ExecuteProcess.executeProcessReturnVector(rpmCommandArray, returnVector, returnErrorVector); 128 String returnString = (String) returnVector.get(0); 129 returnString = returnString.replaceAll("//","/"); 130 131 String log = rpmCommand + "<br><b>Returns: " + returnString + "</b><br>"; 132 LogManager.addCommandsLogfileComment(log); 133 134 installDir = returnString; 135 } 136 137 return installDir; 138 } 139 140 public void installPackage(PackageDescription packageData) { 141 // get ProductDescription for logging mechanism 142 ProductDescription productData = SetupDataProvider.getProductDescription(); 143 InstallData data = InstallData.getInstance(); 144 145 // String log = "<br><b>Package: " + packageData.getName() + "</b>"; 146 // LogManager.addCommandsLogfileComment(log); 147 String log = ""; 148 149 // setting installDir 150 String installDir = data.getInstallDir(); 151 String packagePath = data.getPackagePath(); 152 153 if (( packageData.getPkgSubdir() != null ) && ( ! packageData.getPkgSubdir().equals("") )) { 154 File completePackageFile = new File(packagePath, packageData.getPkgSubdir()); 155 packagePath = completePackageFile.getPath(); 156 } 157 158 String packageName = packageData.getPackageName(); 159 160 if (( packageName.equals("")) || ( packageName == null )) { 161 log = "<b>No package name specified. Nothing to do</b>"; 162 LogManager.addCommandsLogfileComment(log); 163 } else { 164 log = "<b>Package Name: " + packageName + "</b>"; 165 LogManager.addCommandsLogfileComment(log); 166 167 File completePackage = new File(packagePath, packageName); 168 packageName = completePackage.getPath(); 169 170 if ( completePackage.exists() ) { 171 String relocations = helper.getRelocationString(packageData, packageName); 172 if ( relocations != null ) { 173 // Problem: If Prefix = "/" the packages are not relocatable with RPM version 3.x . 174 // Therefore Prefix has to be "/opt" in spec file, although packages shall not be 175 // relocatable (except for installations with root privileges). So /opt has to be 176 // listed left and right of equal sign: --relocate /opt=<installDir>/opt 177 // -> /opt has to be added to the installDir 178 File localInstallDir = new File(installDir, relocations); // "/" -> "/opt" 179 String localInstallDirString = localInstallDir.getPath(); 180 181 // Fixing problem with installation directory and RPM version 3.x 182 String fixedInstallDir = helper.fixInstallationDirectory(localInstallDirString); 183 relocations = relocations + "=" + fixedInstallDir; 184 // relocations: "/opt/staroffice8=" + fixedInstallDir; 185 } 186 187 String rpmCommand = ""; 188 String[] rpmCommandArray; 189 String databasePath = null; 190 String databaseString = ""; 191 boolean useLocalDatabase = false; 192 193 if ( data.isUserInstallation() ) { 194 databasePath = data.getDatabasePath(); 195 if ( databasePath == null ) { 196 databasePath = helper.getLinuxDatabasePath(data); 197 data.setDatabasePath(databasePath); 198 } 199 } 200 201 if (( databasePath != null ) && (! databasePath.equalsIgnoreCase("null"))) { 202 databaseString = "--dbpath"; 203 useLocalDatabase = true; 204 } 205 206 if (useLocalDatabase) { 207 if ( relocations != null ) 208 { 209 rpmCommand = "rpm --upgrade --ignoresize -vh " + 210 "--relocate " + relocations + " " + databaseString + 211 " " + databasePath + " " + packageName; 212 rpmCommandArray = new String[9]; 213 rpmCommandArray[0] = "rpm"; 214 rpmCommandArray[1] = "--upgrade"; 215 rpmCommandArray[2] = "--ignoresize"; 216 rpmCommandArray[3] = "-vh"; 217 rpmCommandArray[4] = "--relocate"; 218 rpmCommandArray[5] = relocations; 219 rpmCommandArray[6] = databaseString; 220 rpmCommandArray[7] = databasePath; 221 rpmCommandArray[8] = packageName; 222 } else { 223 rpmCommand = "rpm --upgrade --ignoresize -vh " + 224 databaseString + " " + databasePath + " " + packageName; 225 rpmCommandArray = new String[7]; 226 rpmCommandArray[0] = "rpm"; 227 rpmCommandArray[1] = "--upgrade"; 228 rpmCommandArray[2] = "--ignoresize"; 229 rpmCommandArray[3] = "-vh"; 230 rpmCommandArray[4] = databaseString; 231 rpmCommandArray[5] = databasePath; 232 rpmCommandArray[6] = packageName; 233 } 234 } else { 235 if ( relocations != null ) 236 { 237 rpmCommand = "rpm --upgrade --ignoresize -vh " + 238 "--relocate " + relocations + " " + packageName; 239 rpmCommandArray = new String[7]; 240 rpmCommandArray[0] = "rpm"; 241 rpmCommandArray[1] = "--upgrade"; 242 rpmCommandArray[2] = "--ignoresize"; 243 rpmCommandArray[3] = "-vh"; 244 rpmCommandArray[4] = "--relocate"; 245 rpmCommandArray[5] = relocations; 246 rpmCommandArray[6] = packageName; 247 } else { 248 rpmCommand = "rpm --upgrade --ignoresize -vh " + packageName; 249 rpmCommandArray = new String[5]; 250 rpmCommandArray[0] = "rpm"; 251 rpmCommandArray[1] = "--upgrade"; 252 rpmCommandArray[2] = "--ignoresize"; 253 rpmCommandArray[3] = "-vh"; 254 rpmCommandArray[4] = packageName; 255 } 256 } 257 258 Vector returnVector = new Vector(); 259 Vector returnErrorVector = new Vector(); 260 // int returnValue = SystemManager.executeProcessReturnVector(rpmCommand, returnVector, returnErrorVector); 261 int returnValue = ExecuteProcess.executeProcessReturnVector(rpmCommandArray, returnVector, returnErrorVector); 262 263 if ( returnValue == 0 ) { 264 log = rpmCommand + "<br><b>Returns: " + returnValue + " Successful installation</b><br>"; 265 LogManager.addCommandsLogfileComment(log); 266 } else { // an error occured during installation 267 if ( packageData.installCanFail() ) { 268 log = rpmCommand + "<br><b>Returns: " + returnValue + " Problem during installation. Can be ignored.</b><br>"; 269 LogManager.addCommandsLogfileComment(log); 270 } else { 271 log = rpmCommand + "<br><b>Returns: " + returnValue + " Error during installation</b><br>"; 272 LogManager.addCommandsLogfileComment(log); 273 for (int i = 0; i < returnErrorVector.size(); i++) { 274 LogManager.addCommandsLogfileComment((String)returnErrorVector.get(i)); 275 } 276 data.setIsErrorInstallation(true); 277 } 278 } 279 280 // saving installation state at package 281 packageData.setIsNewInstalled(true); 282 } else { 283 log = "<b>Error: Did not find package " + packageName + "</b><br>"; 284 System.err.println(log); 285 String message = ResourceManager.getString("String_File_Not_Found") + ": " + packageName; 286 String title = ResourceManager.getString("String_Error"); 287 Informer.showErrorMessage(message, title); 288 LogManager.addCommandsLogfileComment(log); 289 data.setIsErrorInstallation(true); 290 } 291 } 292 } 293 294 public void uninstallPackage(PackageDescription packageData) { 295 // get ProductDescription for logging mechanism 296 ProductDescription productData = SetupDataProvider.getProductDescription(); 297 InstallData data = InstallData.getInstance(); 298 299 String log = ""; 300 // String log = "<br><b>Package: " + packageData.getName() + "</b>"; 301 // LogManager.addCommandsLogfileComment(log); 302 303 String rpmPackageName = packageData.getPackageName(); 304 305 if (( rpmPackageName.equals("")) || ( rpmPackageName == null )) { 306 log = "<b>No package name specified. Nothing to do</b>"; 307 LogManager.addCommandsLogfileComment(log); 308 } else { 309 log = "<b>Package Name: " + rpmPackageName + "</b>"; 310 LogManager.addCommandsLogfileComment(log); 311 312 String packageName = packageData.getPkgRealName(); 313 String databasePath = data.getDatabasePath(); 314 String databaseString = ""; 315 boolean useLocalDatabase = false; 316 String rpmCommand; 317 String[] rpmCommandArray; 318 319 if (( databasePath != null ) && (! databasePath.equalsIgnoreCase("null"))) { 320 databaseString = "--dbpath"; 321 useLocalDatabase = true; 322 } 323 324 if (useLocalDatabase) { 325 rpmCommand = "rpm -ev" + " " + databaseString + " " + databasePath + " " + packageName; 326 rpmCommandArray = new String[5]; 327 rpmCommandArray[0] = "rpm"; 328 rpmCommandArray[1] = "-ev"; 329 rpmCommandArray[2] = databaseString; 330 rpmCommandArray[3] = databasePath; 331 rpmCommandArray[4] = packageName; 332 } else { 333 rpmCommand = "rpm -ev" + " " + packageName; 334 rpmCommandArray = new String[3]; 335 rpmCommandArray[0] = "rpm"; 336 rpmCommandArray[1] = "-ev"; 337 rpmCommandArray[2] = packageName; 338 } 339 340 Vector returnVector = new Vector(); 341 Vector returnErrorVector = new Vector(); 342 int returnValue = ExecuteProcess.executeProcessReturnVector(rpmCommandArray, returnVector, returnErrorVector); 343 344 if ( returnValue == 0 ) { 345 log = rpmCommand + "<br><b>Returns: " + returnValue + " Successful uninstallation</b><br>"; 346 LogManager.addCommandsLogfileComment(log); 347 } else { // an error occured during installation 348 log = rpmCommand + "<br><b>Returns: " + returnValue + " Error during uninstallation</b><br>"; 349 LogManager.addCommandsLogfileComment(log); 350 for (int i = 0; i < returnErrorVector.size(); i++) { 351 LogManager.addCommandsLogfileComment((String)returnErrorVector.get(i)); 352 } 353 data.setIsErrorInstallation(true); 354 } 355 } 356 } 357 358 public boolean isPackageInstalledClassic(PackageDescription packageData, InstallData installData) { 359 360 boolean isInstalled = false; 361 boolean doCheck = false; 362 363 // only checking existing packages (and always at uninstallation) 364 if ( (packageData.pkgExists()) || (installData.isUninstallationMode()) ) { 365 doCheck = true; 366 } 367 368 String rpmPackageName = packageData.getPackageName(); 369 370 if ( rpmPackageName.equals("") ) { 371 rpmPackageName = null; 372 } 373 374 if (( rpmPackageName != null ) && ( doCheck )) { 375 376 String databaseString = ""; 377 String databasePath = null; 378 String packageName = packageData.getPkgRealName(); 379 Vector allPackages = null; 380 boolean useLocalDatabase = false; 381 382 if (installData.isUserInstallation()) { 383 databasePath = installData.getDatabasePath(); 384 } 385 386 if (( databasePath != null ) && (! databasePath.equals("null"))) { 387 databaseString = "--dbpath"; 388 useLocalDatabase = true; 389 } 390 391 if (packageName != null) { 392 393 String rpmCommand; 394 String[] rpmCommandArray; 395 396 if (useLocalDatabase) { 397 rpmCommand = "rpm" + " " + databaseString + " " + databasePath + " --query " + packageName; 398 rpmCommandArray = new String[5]; 399 rpmCommandArray[0] = "rpm"; 400 rpmCommandArray[1] = databaseString; 401 rpmCommandArray[2] = databasePath; 402 rpmCommandArray[3] = "--query"; 403 rpmCommandArray[4] = packageName; 404 } else { 405 rpmCommand = "rpm" + " --query " + packageName; 406 rpmCommandArray = new String[3]; 407 rpmCommandArray[0] = "rpm"; 408 rpmCommandArray[1] = "--query"; 409 rpmCommandArray[2] = packageName; 410 } 411 412 int returnValue = ExecuteProcess.executeProcessReturnValue(rpmCommandArray); 413 414 if ( returnValue == 0 ) { 415 isInstalled = true; 416 packageData.setWasAlreadyInstalled(true); // needed for logging 417 String log = rpmCommand + "<br><b>Returns: " + returnValue + " Package is installed" + "</b><br>"; 418 LogManager.addCommandsLogfileComment(log); 419 } else { 420 String log = rpmCommand + "<br><b>Returns: " + returnValue + " Package is not installed" + "</b><br>"; 421 LogManager.addCommandsLogfileComment(log); 422 } 423 } 424 } 425 426 return isInstalled; 427 } 428 429 private void queryAllDatabase(InstallData installData) { 430 431 String databaseString = ""; 432 String databasePath = null; 433 HashMap map = new HashMap();; 434 boolean useLocalDatabase = false; 435 436 if (installData.isUserInstallation()) { 437 databasePath = installData.getDatabasePath(); 438 } 439 440 if (( databasePath != null ) && (! databasePath.equals("null"))) { 441 databaseString = "--dbpath"; 442 useLocalDatabase = true; 443 } 444 445 String rpmCommand; 446 String[] rpmCommandArray; 447 448 if (useLocalDatabase) { 449 rpmCommand = "rpm" + " " + databaseString + " " + databasePath + " --query" + " -a"; 450 rpmCommandArray = new String[5]; 451 rpmCommandArray[0] = "rpm"; 452 rpmCommandArray[1] = databaseString; 453 rpmCommandArray[2] = databasePath; 454 rpmCommandArray[3] = "--query"; 455 rpmCommandArray[4] = "-a"; 456 } else { 457 rpmCommand = "rpm" + " --query" + " -a"; 458 rpmCommandArray = new String[3]; 459 rpmCommandArray[0] = "rpm"; 460 rpmCommandArray[1] = "--query"; 461 rpmCommandArray[2] = "-a"; 462 } 463 464 Vector returnVector = new Vector(); 465 Vector returnErrorVector = new Vector(); 466 int returnValue = ExecuteProcess.executeProcessReturnVector(rpmCommandArray, returnVector, returnErrorVector); 467 468 String log = rpmCommand + "<br><b>Returns: " + returnValue + "</b><br>"; 469 LogManager.addCommandsLogfileComment(log); 470 String value = "1"; 471 472 if ( ! returnVector.isEmpty()) { 473 for (int i = 0; i < returnVector.size(); i++) { 474 String onePackage = (String)returnVector.get(i); 475 int pos1 = onePackage.lastIndexOf("-"); 476 int pos2 = onePackage.substring(0, pos1).lastIndexOf("-"); 477 map.put(onePackage.substring(0, pos2), value); 478 } 479 } 480 481 installData.setDatabaseQueried(true); 482 installData.setDatabaseMap(map); 483 } 484 485 public boolean isPackageInstalled(PackageDescription packageData, InstallData installData) { 486 487 boolean isInstalled = false; 488 boolean doCheck = false; 489 490 // only checking existing packages (and always at uninstallation) 491 if ( (packageData.pkgExists()) || (installData.isUninstallationMode()) ) { 492 doCheck = true; 493 } 494 495 String rpmPackageName = packageData.getPackageName(); 496 497 if ( rpmPackageName.equals("") ) { 498 rpmPackageName = null; 499 } 500 501 if (( rpmPackageName != null ) && ( doCheck )) { 502 String packageName = packageData.getPkgRealName(); 503 504 if (packageName != null) { 505 506 HashMap map = null; 507 if ( ! installData.databaseQueried() ) { 508 queryAllDatabase(installData); 509 } 510 511 map = installData.getDatabaseMap(); 512 513 if ( map.containsKey(packageName)) { 514 isInstalled = true; 515 } 516 } else { 517 System.err.println("Error: No packageName defined for package: " + packageData.getPackageName()); 518 } 519 } 520 521 return isInstalled; 522 } 523 524 public boolean isInstallSetPackageOlder(PackageDescription packageData, InstallData installData) { 525 boolean installSetPackageIsOlder = false; 526 boolean checkIfInstalledIsOlder = false; 527 installSetPackageIsOlder = findOlderPackage(packageData, installData, checkIfInstalledIsOlder); 528 return installSetPackageIsOlder; 529 } 530 531 public boolean isInstalledPackageOlder(PackageDescription packageData, InstallData installData) { 532 boolean installedPackageIsOlder = false; 533 boolean checkIfInstalledIsOlder = true; 534 installedPackageIsOlder = findOlderPackage(packageData, installData, checkIfInstalledIsOlder); 535 return installedPackageIsOlder; 536 } 537 538 private boolean findOlderPackage(PackageDescription packageData, InstallData installData, boolean checkIfInstalledIsOlder) { 539 540 // The information about the new package is stored in packageData (the version and the release). 541 // This information can be stored in xpd files. If it is not stored in xpd files, it is determined 542 // during installation process by querying the rpm file. This process costs much time and should 543 // therefore be done by the process, that creates the xpd files. On the other hand this requires, 544 // that the xpd files contain the correct information. 545 546 boolean isOlder = false; 547 548 // get the version of the installed package 549 String rpmPackageName = packageData.getPackageName(); 550 String log; 551 552 if ( rpmPackageName.equals("")) { 553 rpmPackageName = null; 554 } 555 556 if ( rpmPackageName != null ) { 557 String databaseString = ""; 558 String databasePath = null; 559 String packageName = packageData.getPkgRealName(); 560 Vector allPackages = null; 561 boolean useLocalDatabase = false; 562 563 if (installData.isUserInstallation()) { 564 databasePath = installData.getDatabasePath(); 565 } 566 567 if (( databasePath != null ) && (! databasePath.equals("null"))) { 568 databaseString = "--dbpath"; 569 useLocalDatabase = true; 570 } 571 572 if (packageName != null) { 573 // Collect information about the installed package by querying the database. 574 // Instead of rpm file name, the real package name has to be used. 575 576 String rpmCommand; 577 String[] rpmCommandArray; 578 579 if (useLocalDatabase) { 580 rpmCommand = "rpm" + " " + databaseString + " " + databasePath + " -q --queryformat %{VERSION}\\n " + packageName; 581 rpmCommandArray = new String[7]; 582 rpmCommandArray[0] = "rpm"; 583 rpmCommandArray[1] = databaseString; 584 rpmCommandArray[2] = databasePath; 585 rpmCommandArray[3] = "-q"; 586 rpmCommandArray[4] = "--queryformat"; 587 rpmCommandArray[5] = "%{VERSION}\\n"; 588 rpmCommandArray[6] = packageName; 589 } else { 590 rpmCommand = "rpm" + " -q --queryformat %{VERSION}\\n " + packageName; 591 rpmCommandArray = new String[5]; 592 rpmCommandArray[0] = "rpm"; 593 rpmCommandArray[1] = "-q"; 594 rpmCommandArray[2] = "--queryformat"; 595 rpmCommandArray[3] = "%{VERSION}\\n"; 596 rpmCommandArray[4] = packageName; 597 } 598