ProductInformations.java

  1. /**
  2.  * Copyright (C) 2009 eXo Platform SAS.
  3.  *
  4.  * This is free software; you can redistribute it and/or modify it
  5.  * under the terms of the GNU Lesser General Public License as
  6.  * published by the Free Software Foundation; either version 2.1 of
  7.  * the License, or (at your option) any later version.
  8.  *
  9.  * This software is distributed in the hope that it will be useful,
  10.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  12.  * Lesser General Public License for more details.
  13.  *
  14.  * You should have received a copy of the GNU Lesser General Public
  15.  * License along with this software; if not, write to the Free
  16.  * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
  17.  * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
  18.  */
  19. package org.exoplatform.commons.info;

  21. import org.exoplatform.commons.api.settings.SettingService;
  22. import org.exoplatform.commons.api.settings.SettingValue;
  23. import org.exoplatform.commons.api.settings.data.Context;
  24. import org.exoplatform.commons.api.settings.data.Scope;
  25. import org.exoplatform.container.configuration.ConfigurationManager;
  26. import org.exoplatform.container.xml.InitParams;
  27. import org.exoplatform.services.jcr.RepositoryService;
  28. import org.exoplatform.services.jcr.core.ManageableRepository;
  29. import org.exoplatform.services.jcr.ext.app.SessionProviderService;
  30. import org.exoplatform.services.jcr.ext.common.SessionProvider;
  31. import org.exoplatform.services.jcr.ext.hierarchy.NodeHierarchyCreator;
  32. import org.exoplatform.services.log.ExoLogger;
  33. import org.exoplatform.services.log.Log;
  34. import org.exoplatform.settings.jpa.entity.SettingsEntity;
  35. import org.picocontainer.Startable;

  37. import javax.jcr.*;
  38. import java.io.*;
  39. import java.text.DateFormat;
  40. import java.text.SimpleDateFormat;
  41. import java.util.*;
  42. import java.util.stream.Collectors;

  44. /**
  45.  * @author <a href="mailto:anouar.chattouna@exoplatform.com">Anouar
  46.  *         Chattouna</a>
  47.  * @version $Revision$
  48.  */
  49. public class ProductInformations implements Startable {

  51.   public static final String     product_Information                   = "ProductInformation";

  53.   public static final String     ENTERPRISE_EDITION                    = "ENTERPRISE";

  55.   public static final String     EXPRESS_EDITION                       = "EXPRESS";

  57.   public static final String     EDITION                               = "edition";

  59.   public static final String     KEY_GENERATION_DATE                   = "key generation date";

  61.   public static final String     DELAY                                 = "delay";

  63.   public static final String     PRODUCT_CODE                          = "productCode";

  65.   public static final String     PRODUCT_KEY                           = "productKey";

  67.   public static final String     NB_USERS                              = "number of users";

  69.   public static final String     PRODUCT_GROUP_ID                      = "product.groupId";

  71.   public static final String     PRODUCT_REVISION                      = "product.revision";

  73.   public static final String     PRODUCT_BUILD_NUMBER                  = "product.buildNumber";

  75.   public static final String     WORKING_WORSPACE_NAME                 = "working.worspace.name";

  77.   public static final String     PRODUCT_VERSIONS_DECLARATION_FILE     = "product.versions.declaration.file";

  79.   /**
  80.    * Constant that will be used in nodeHierarchyCreator.getJcrPath: it represents
  81.    * the Application data root node Alias
  82.    */
  83.   public static final String     EXO_APPLICATIONS_DATA_NODE_ALIAS      = "exoApplicationDataNode";

  85.   /**
  86.    * Service application data node name
  87.    */
  88.   public static final String     UPGRADE_PRODUCT_SERVICE_NODE_NAME     = "ProductInformationsService";

  90.   /**
  91.    * node name where the Product version declaration is
  92.    */
  93.   public static final String     PRODUCT_VERSION_DECLARATION_NODE_NAME = "productVersionDeclarationNode";

  95.   private static final Log       LOG                                   = ExoLogger.getLogger(ProductInformations.class);

  97.   public String                  applicationDataRootNodePath           = null;

  99.   private String                 productVersionDeclarationNodePath     = null;

  101.   private String                 workspaceName                         = null;

  103.   private Properties             productInformationProperties          = new Properties();

  105.   private Map<String, String>    productInformation                    = new HashMap<>();

  107.   private boolean                firstRun                              = false;

  109.   private SettingService         settingService;

  111.   private NodeHierarchyCreator   nodeHierarchyCreator;

  113.   private RepositoryService      repositoryService                     = null;

  115.   private SessionProviderService sessionProviderService                = null;

  117.   public ProductInformations(ConfigurationManager cmanager,
  118.                              NodeHierarchyCreator nodeHierarchyCreator,
  119.                              InitParams initParams,
  120.                              SettingService settingService,
  121.                              SessionProviderService sessionProviderService,
  122.                              RepositoryService repositoryService) {
  123.     this.repositoryService = repositoryService;
  124.     this.sessionProviderService = sessionProviderService;
  125.     this.settingService = settingService;
  126.     this.nodeHierarchyCreator = nodeHierarchyCreator;
  127.     if (!initParams.containsKey(PRODUCT_VERSIONS_DECLARATION_FILE)) {
  128.       if (LOG.isErrorEnabled()) {
  129.         LOG.error("Couldn't find the init value param: " + PRODUCT_VERSIONS_DECLARATION_FILE);
  130.       }
  131.       return;
  132.     }
  133.     String filePath = initParams.getValueParam(PRODUCT_VERSIONS_DECLARATION_FILE).getValue();
  134.     try {
  135.       if (LOG.isInfoEnabled()) {
  136.         LOG.info("Read products versions from " + filePath);
  137.       }
  138.       InputStream inputStream = cmanager.getInputStream(filePath);
  139.       productInformationProperties.load(inputStream);
  140.     } catch (IOException exception) {
  141.       if (LOG.isErrorEnabled()) {
  142.         LOG.error("Couldn't parse the file " + filePath, exception);
  143.       }
  144.       return;
  145.     } catch (Exception exception) {
  146.       // ConfigurationManager.getInputStream() throws Exception().
  147.       // It's from another project and we cannot modify it. So we have to catch
  148.       // Exception
  149.       if (LOG.isErrorEnabled()) {
  150.         LOG.error("Error occured while reading the file " + filePath, exception);
  151.       }
  152.       return;
  153.     }
  154.     if (initParams.containsKey(WORKING_WORSPACE_NAME)) {
  155.       workspaceName = initParams.getValueParam(WORKING_WORSPACE_NAME).getValue();
  156.     }
  157.   }

  159.   public String getEdition() throws MissingProductInformationException {
  160.     return productInformation.get(EDITION);
  161.   }

  163.   public String getNumberOfUsers() throws MissingProductInformationException {
  164.     return productInformation.get(NB_USERS);
  165.   }

  167.   public String getDateOfLicence() throws MissingProductInformationException {
  168.     return productInformation.get(KEY_GENERATION_DATE);
  169.   }

  171.   public String getDuration() throws MissingProductInformationException {
  172.     return productInformation.get(DELAY);
  173.   }

  175.   public String getProductCode() throws MissingProductInformationException {
  176.     return productInformation.get(PRODUCT_CODE);
  177.   }

  179.   public String getProductKey() throws MissingProductInformationException {
  180.     return productInformation.get(PRODUCT_KEY);
  181.   }

  183.   /**
  184.    * @return This method returns the current product's version.
  185.    */
  186.   public String getVersion() throws MissingProductInformationException {
  187.     return getVersion(getCurrentProductGroupId());
  188.   }

  190.   /**
  191.    * @return This method return the product version, selected by its maven
  192.    *         groupId.
  193.    */
  194.   public String getVersion(String productGroupId) throws MissingProductInformationException {
  195.     if (!productInformationProperties.containsKey(productGroupId)) {
  196.       throw new MissingProductInformationException(productGroupId);
  197.     }
  198.     return productInformationProperties.getProperty(productGroupId);
  199.   }

  201.   /**
  202.    * @return the product.buildNumber property value.
  203.    */
  204.   public String getBuildNumber() throws MissingProductInformationException {
  205.     if (!productInformationProperties.containsKey(PRODUCT_BUILD_NUMBER)) {
  206.       throw new MissingProductInformationException(PRODUCT_BUILD_NUMBER);
  207.     }
  208.     return productInformationProperties.getProperty(PRODUCT_BUILD_NUMBER);
  209.   }

  211.   /**
  212.    * @return the product.revision property value.
  213.    */
  214.   public String getRevision() throws MissingProductInformationException {
  215.     if (!productInformationProperties.containsKey(PRODUCT_REVISION)) {
  216.       throw new MissingProductInformationException(PRODUCT_REVISION);
  217.     }
  218.     return productInformationProperties.getProperty(PRODUCT_REVISION);
  219.   }

  221.   /**
  222.    * @return the current product's maven group id.
  223.    */
  224.   public String getCurrentProductGroupId() throws MissingProductInformationException {
  225.     if (!productInformationProperties.containsKey(PRODUCT_GROUP_ID)) {
  226.       throw new MissingProductInformationException(PRODUCT_GROUP_ID);
  227.     }
  228.     return productInformationProperties.getProperty(PRODUCT_GROUP_ID);
  229.   }

  231.   /**
  232.    * @return the platform.version property. This method return the platform
  233.    *         version.
  234.    */
  235.   public String getPreviousVersion() throws MissingProductInformationException {
  236.     return getPreviousVersion(getCurrentProductGroupId());
  237.   }

  239.   /**
  240.    * @return the platform.version property. This method return the platform
  241.    *         version.
  242.    */
  243.   public String getPreviousVersion(String productGroupId) throws MissingProductInformationException {
  244.     if (!productInformation.containsKey(productGroupId)) {
  245.       throw new MissingProductInformationException(productGroupId);
  246.     }
  247.     return productInformation.get(productGroupId);
  248.   }

  250.   /**
  251.    * @return an empty string if the properties file is not found, otherwise the
  252.    *         platform.buildNumber property. This method return the build number of
  253.    *         the platform.
  254.    */
  255.   public String getPreviousBuildNumber() throws MissingProductInformationException {
  256.     if (!productInformation.containsKey(PRODUCT_BUILD_NUMBER)) {
  257.       throw new MissingProductInformationException(PRODUCT_BUILD_NUMBER);
  258.     }
  259.     return productInformation.get(PRODUCT_BUILD_NUMBER);
  260.   }

  262.   /**
  263.    * @return the value of product.revision property. This method return the
  264.    *         current revison of the platform.
  265.    */
  266.   public String getPreviousRevision() throws MissingProductInformationException {
  267.     if (!productInformation.containsKey(PRODUCT_REVISION)) {
  268.       throw new MissingProductInformationException(PRODUCT_REVISION);
  269.     }
  270.     return productInformation.get(PRODUCT_REVISION);
  271.   }

  273.   public boolean isFirstRun() {
  274.     return this.firstRun;
  275.   }

  277.   /**
  278.    * This method migrate from the JCR the stored products versions to JPA. If it's
  279.    * the first server start up, then store the declared one.
  280.    */
  281.   public void start() {
  282.     try {
  283.       migrateProductInformation();
  284.       // Load product information from DB
  285.       Map<String, SettingValue> productInformationSettings =
  286.                                                            settingService.getSettingsByContextAndScope(Context.GLOBAL.getName(),
  287.                                                                                                        Context.GLOBAL.getId(),
  288.                                                                                                        Scope.APPLICATION.getName(),
  289.                                                                                                        product_Information);
  290.       if (productInformationSettings != null && !productInformationSettings.isEmpty()) {
  291.         productInformationSettings.entrySet()
  292.                                   .stream()
  293.                                   .forEach(e -> productInformation.put(e.getKey(), e.getValue().getValue().toString()));

  295.       } else {// This is the first time that this Service starts up
  296.         LOG.info("Platform first run - init and store product Information");
  297.         firstRun = true;
  298.         // Store product information properties in DB
  299.         initProductInformation(productInformationProperties);
  300.         storeProductInformation(productInformation);
  301.       }
  302.     } catch (Exception e) {
  303.       LOG.error("Error while starting product information service - Cause : " + e.getMessage(), e);
  304.     }
  305.   }

  307.   /**
  308.    * This method is called by eXo Kernel when stopping the parent ExoContainer
  309.    */
  310.   public void stop() {
  311.   }

  313.   public void storeProductInformation(Map<String, String> map) {
  314.     try {
  315.       for (Map.Entry<String, String> entry : map.entrySet()) {
  316.         settingService.set(Context.GLOBAL,
  317.                            Scope.APPLICATION.id(product_Information),
  318.                            entry.getKey(),
  319.                            SettingValue.create(entry.getValue()));
  320.       }
  321.     } catch (Exception e) {
  322.       LOG.error("Error while storing product informations    - Cause : " + e.getMessage(), e);
  323.     }
  324.   }

  326.   public void initProductInformation(Properties properties) {
  327.     properties.entrySet().stream().forEach(entry -> productInformation.put((String) entry.getKey(), (String) entry.getValue()));
  328.   }

  330.   /**
  331.    * Migrate product information from JCR to RDBMS
  332.    */
  333.   public void migrateProductInformation() {
  334.     if (workspaceName == null || workspaceName.equals("")) {
  335.       try {
  336.         workspaceName = repositoryService.getCurrentRepository().getConfiguration().getDefaultWorkspaceName();
  337.         if (LOG.isInfoEnabled()) {
  338.           LOG.info("Workspace wasn't specified, use '" + workspaceName + "' as default workspace of this repository.");
  339.         }
  340.       } catch (RepositoryException exception) {
  341.         LOG.error("Error occured while getting default workspace name.", exception);
  342.         return;
  343.       }
  344.     }
  345.     Session session = null;
  346.     try {
  347.       session = getSession();
  348.       applicationDataRootNodePath = nodeHierarchyCreator.getJcrPath(EXO_APPLICATIONS_DATA_NODE_ALIAS);
  349.       productVersionDeclarationNodePath = applicationDataRootNodePath + "/" + UPGRADE_PRODUCT_SERVICE_NODE_NAME + "/"
  350.           + PRODUCT_VERSION_DECLARATION_NODE_NAME;
  351.       if (session.itemExists(productVersionDeclarationNodePath)) {
  352.         Node productVersionDeclarationNode = (Node) session.getItem(productVersionDeclarationNodePath);
  353.         Node productVersionDeclarationNodeContent = productVersionDeclarationNode.getNode("jcr:content");
  354.         String data = productVersionDeclarationNodeContent.getProperty("jcr:data").getString();
  355.         Properties jcrInformation = new Properties();
  356.         jcrInformation.load(new ByteArrayInputStream(data.getBytes()));
  357.         initProductInformation(jcrInformation);
  358.         storeProductInformation(productInformation);
  359.         productVersionDeclarationNode.getParent().remove();
  360.         LOG.info("productVersionDeclaration node removed!");
  361.         session.save();
  362.       } else {
  363.         LOG.info("No product information to migrate from JCR to RDBMS");
  364.       }
  365.     } catch (LoginException exception) {
  366.       LOG.error("Can't load product informations from the JCR: Error when getting JCR session.", exception);
  367.       return;
  368.     } catch (NoSuchWorkspaceException exception) {
  369.       LOG.error("Can't load product informations from the JCR: Error when getting JCR session.", exception);
  370.       return;
  371.     } catch (RepositoryException exception) {
  372.       LOG.error("Can't load product informations from the JCR!", exception);
  373.       return;
  374.     } catch (IOException exception) {
  375.       LOG.error("Can't load product informations from the JCR: the data stored in the JCR couldn't be parsed.", exception);
  376.       return;
  377.     }
  378.     finally {
  379.       if (session != null) {
  380.         session.logout();
  381.       }
  382.     }
  383.   }

  385.   public void setUnlockInformation(Properties unlockInformation) {
  386.     productInformation.put(EDITION, (String) unlockInformation.get(EDITION));
  387.     productInformation.put(NB_USERS, (String) unlockInformation.get(NB_USERS));
  388.     productInformation.put(PRODUCT_KEY, (String) unlockInformation.get(PRODUCT_KEY));
  389.     productInformation.put(PRODUCT_CODE, (String) unlockInformation.get(PRODUCT_CODE));
  390.     productInformation.put(DELAY, (String) unlockInformation.get(DELAY));
  391.     productInformation.put(KEY_GENERATION_DATE, (String) unlockInformation.get(KEY_GENERATION_DATE));
  392.   }

  394.   public void setPreviousVersionsIfFirstRun(String defaultVersion) {
  395.     if (isFirstRun()) {
  396.       initProductInformation(productInformationProperties);
  397.       productInformation.forEach((key, value) -> productInformation.put(key, defaultVersion));
  398.     }
  399.   }

  401.   public String getWorkspaceName() {
  402.     return workspaceName;
  403.   }

  405.   public String getProductVersionDeclarationNodePath() {
  406.     return this.productVersionDeclarationNodePath;
  407.   }

  409.   private static String currentFlag() {
  410.     DateFormat dateFormat = new SimpleDateFormat("yyyyMMddHHmmss");
  411.     return dateFormat.format(Calendar.getInstance(TimeZone.getDefault()).getTime());
  412.   }

  414.   public void setProductInformationProperties(Properties productInformationProperties) {
  415.     this.productInformationProperties = productInformationProperties;
  416.   }

  418.   public Properties getProductInformationProperties() {
  419.     return productInformationProperties;
  420.   }

  422.   public Map<String, String> getProductInformation() {
  423.     return productInformation;
  424.   }

  426.   public void setFirstRun(boolean firstRun) {
  427.     this.firstRun = firstRun;
  428.   }

  430.   private Session getSession() throws RepositoryException, LoginException, NoSuchWorkspaceException {
  431.     SessionProvider sessionProvider = sessionProviderService.getSystemSessionProvider(null);
  432.     ManageableRepository repository = repositoryService.getCurrentRepository();
  433.     return sessionProvider.getSession(workspaceName, repository);
  434.   }

  436. }
Created with JaCoCo 0.7.6.201602180812