1 /*
   2  * Copyright (c) 2014, 2016 Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  */
   5 package com.oracle.appbundlers.utils.installers;
   6 
   7 import static com.oracle.appbundlers.utils.Config.CONFIG_INSTANCE;
   8 import static com.oracle.appbundlers.utils.Utils.runCommand;
   9 import static org.testng.Assert.assertTrue;
  10 
  11 import java.io.IOException;
  12 import java.nio.file.Path;
  13 import java.nio.file.Paths;
  14 import java.util.Arrays;
  15 import java.util.Map;
  16 import java.util.concurrent.ExecutionException;
  17 import java.util.logging.Level;
  18 import java.util.logging.Logger;
  19 import java.util.regex.Pattern;
  20 import java.util.stream.Collectors;
  21 
  22 import org.testng.Assert;
  23 
  24 import com.oracle.appbundlers.utils.AppWrapper;
  25 import com.oracle.appbundlers.utils.BundlerUtils;
  26 import com.oracle.appbundlers.utils.ProcessOutput;
  27 import com.oracle.appbundlers.utils.Utils;
  28 import com.oracle.tools.packager.linux.LinuxRpmBundler;
  29 
  30 /**
  31  * @author Dmitry Ginzburg <dmitry.x.ginzburg@oracle.com>
  32  */
  33 public class LinuxRPMBundlerUtils extends LinuxAbstractBundlerUtils {
  34 
  35     private static final Logger LOG = Logger
  36             .getLogger(LinuxDebBundlerUtils.class.getName());
  37 
  38     {
  39         verificators.put(LICENSE_TYPE,
  40                 (value, app, applicationTitle) -> getRpmInfoContainsVerificator(
  41                         "License\\s*:\\s*" + Pattern.quote(value.toString())
  42                                 + "\\s*").verify(value, app, applicationTitle));
  43         verificators.put(ICON, getIconVerificator());
  44         verificators.put(TITLE, (value, app, applicationTitle) -> {
  45             getTitleVerificator().verify(value, app, applicationTitle);
  46             getRpmInfoContainsVerificator(
  47                     "Summary\\s*:\\s*" + Pattern.quote(value.toString()))
  48                             .verify(value, app, applicationTitle);
  49         });
  50         verificators.put(VENDOR,
  51                 (value, app, applicationTitle) -> getRpmInfoContainsVerificator(
  52                         "Vendor\\s*:\\s*" + Pattern.quote(value.toString()))
  53                                 .verify(value, app, applicationTitle));
  54         verificators.put(VERSION,
  55                 (value, app, applicationTitle) -> getRpmInfoContainsVerificator(
  56                         "Version\\s*:\\s*" + Pattern.quote(value.toString()))
  57                                 .verify(value, app, applicationTitle));
  58         verificators.put(DESCRIPTION, (value, app,
  59                 applicationTitle) -> getRpmInfoContainsVerificator(
  60                         "Description\\s*:\\s*"
  61                                 + Pattern.quote(value.toString())).verify(value,
  62                                         app, applicationTitle));
  63         verificators.put(CATEGORY, getCategoryVerificator());
  64         verificators.put(FILE_ASSOCIATIONS, getFileAssociationVerificator());
  65         verificators.put(LinuxRpmBundler_BUNDLE_NAME,
  66                 (value, app, applicationTitle) -> {
  67                     try {
  68                         ProcessOutput rpmGetInfoOutput = runCommand(
  69                                 Arrays.asList("rpm", "-ql", value.toString()),
  70                                 CONFIG_INSTANCE.getRunTimeout());
  71                         assertTrue(rpmGetInfoOutput.exitCode() == 0);
  72                     } catch (IOException | ExecutionException ex) {
  73                         throw new RuntimeException(ex);
  74                     }
  75                 });
  76         verificators.put(SERVICE_HINT, getServiceHintVerificator());
  77     }
  78 
  79     public LinuxRPMBundlerUtils() {
  80         super(BundleType.INSTALLER, BundlerUtils.RPM);
  81     }
  82 
  83     private VerificationMethod getRpmInfoContainsVerificator(String regex) {
  84         return (value, app, applicationTitle) -> {
  85             try {
  86                 Path rpmFile = findByExtension(app.getBundlesDir(), "rpm",
  87                         ROOT_DIRECTORY_DEPTH);
  88                 String output = Utils
  89                         .runCommand(
  90                                 new String[] { "rpm", "-qip",
  91                                         rpmFile.toString() },
  92                                 CONFIG_INSTANCE.getRunTimeout())
  93                         .getOutputStream().stream()
  94                         .collect(Collectors.joining(System.lineSeparator()));
  95                 assertTrue(Pattern.compile(regex).matcher(output).find());
  96             } catch (IOException | ExecutionException e) {
  97                 Assert.fail(e.getMessage(), e);
  98             }
  99         };
 100     }
 101 
 102     @Override
 103     public String install(AppWrapper app, String applicationTitle)
 104             throws IOException {
 105         String rpmPath = findByExtension(app.getBundlesDir(), "rpm",
 106                 ROOT_DIRECTORY_DEPTH).toString();
 107         try {
 108             LOG.log(Level.INFO, "Installing {0}.", rpmPath);
 109             String[] cmd = new String[] { "sudo", "rpm", "--install",
 110                     "--nodeps", rpmPath };
 111             Utils.runCommand(cmd, true, CONFIG_INSTANCE.getInstallTimeout());
 112             LOG.info("Installing done.");
 113         } catch (ExecutionException e) {
 114             throw new IOException(e);
 115         }
 116         return getInstalledExecutableLocation(app, applicationTitle).toString();
 117     }
 118 
 119     @Override
 120     public void uninstall(AppWrapper app, String applicationTitle)
 121             throws IOException {
 122         try {
 123             LOG.log(Level.INFO, "Uninstalling {0}.", applicationTitle);
 124             String[] cmd = new String[] { "sudo", "rpm", "-e", "--nodeps",
 125                     applicationTitle };
 126             Utils.runCommand(cmd, true, CONFIG_INSTANCE.getInstallTimeout());
 127             LOG.info("Uninstalling done.");
 128         } catch (ExecutionException e) {
 129             throw new IOException(e);
 130         }
 131     }
 132 
 133     @Override
 134     public Path getInstalledAppRootLocation(AppWrapper app,
 135             String applicationTitle) {
 136         return Paths.get("/opt", applicationTitle);
 137     }
 138 
 139     @Override
 140     public String getAppName(Map<String, Object> params) {
 141         return LinuxRpmBundler.BUNDLE_NAME.fetchFrom(params);
 142     }
 143 
 144     @Override
 145     public void manualInstall(AppWrapper app) throws IOException {
 146         throw new UnsupportedOperationException("Not supported yet."); // To
 147                                                                        // change
 148                                                                        // body
 149                                                                        // of
 150                                                                        // generated
 151                                                                        // methods,
 152                                                                        // choose
 153                                                                        // Tools
 154                                                                        // |
 155                                                                        // Templates.
 156     }
 157 }