Ejemplo n.º 1
0
  /**
   * Generates an Unpublish bundle for a given bundle id operation (publish/unpublish)
   *
   * @param bundleId The Bundle id of the Bundle we want to generate
   * @param operation Download for publish or un-publish
   * @return The generated requested Bundle file
   * @throws DotPublisherException If fails retrieving the Bundle contents
   * @throws DotDataException If fails finding the system user
   * @throws DotPublishingException If fails initializing the Publisher
   * @throws IllegalAccessException If fails creating new Bundlers instances
   * @throws InstantiationException If fails creating new Bundlers instances
   * @throws DotBundleException If fails generating the Bundle
   * @throws IOException If fails compressing the all the Bundle contents into the final Bundle file
   */
  @SuppressWarnings("unchecked")
  private Map<String, Object> generateBundle(
      String bundleId, PushPublisherConfig.Operation operation)
      throws DotPublisherException, DotDataException, DotPublishingException,
          IllegalAccessException, InstantiationException, DotBundleException, IOException {

    PushPublisherConfig pconf = new PushPublisherConfig();
    PublisherAPI pubAPI = PublisherAPI.getInstance();

    List<PublishQueueElement> tempBundleContents = pubAPI.getQueueElementsByBundleId(bundleId);
    List<PublishQueueElement> assetsToPublish =
        new ArrayList<PublishQueueElement>(); // all assets but contentlets

    for (PublishQueueElement c : tempBundleContents) {
      if (!c.getType().equals("contentlet")) {
        assetsToPublish.add(c);
      }
    }

    pconf.setDownloading(true);
    pconf.setOperation(operation);

    // all types of assets in the queue but contentlets are passed here, which are passed through
    // lucene queries
    pconf.setAssets(assetsToPublish);
    // Queries creation
    pconf.setLuceneQueries(PublisherUtil.prepareQueries(tempBundleContents));
    pconf.setId(bundleId);
    pconf.setUser(APILocator.getUserAPI().getSystemUser());

    // BUNDLERS

    List<Class<IBundler>> bundlers = new ArrayList<Class<IBundler>>();
    List<IBundler> confBundlers = new ArrayList<IBundler>();

    Publisher publisher = new PushPublisher();
    publisher.init(pconf);
    // Add the bundles for this publisher
    for (Class clazz : publisher.getBundlers()) {
      if (!bundlers.contains(clazz)) {
        bundlers.add(clazz);
      }
    }

    // Create a new bundle id for this generated bundle
    String newBundleId = UUID.randomUUID().toString();
    pconf.setId(newBundleId);
    File bundleRoot = BundlerUtil.getBundleRoot(pconf);

    // Run bundlers
    BundlerUtil.writeBundleXML(pconf);
    for (Class<IBundler> c : bundlers) {

      IBundler bundler = c.newInstance();
      confBundlers.add(bundler);
      bundler.setConfig(pconf);
      BundlerStatus bundlerStatus = new BundlerStatus(bundler.getClass().getName());
      // Generate the bundler
      bundler.generate(bundleRoot, bundlerStatus);
    }

    pconf.setBundlers(confBundlers);

    // Compressing bundle
    ArrayList<File> list = new ArrayList<File>();
    list.add(bundleRoot);
    File bundle =
        new File(bundleRoot + File.separator + ".." + File.separator + pconf.getId() + ".tar.gz");

    Map<String, Object> bundleData = new HashMap<String, Object>();
    bundleData.put("id", newBundleId);
    bundleData.put("file", PushUtils.compressFiles(list, bundle, bundleRoot.getAbsolutePath()));
    return bundleData;
  }
Ejemplo n.º 2
0
  /**
   * Allow the user to send or try to send again failed and successfully sent bundles, in order to
   * do that<br>
   * we send the bundle again to que publisher queue job which will try to remote publish again the
   * bundle.
   *
   * @param request HttpRequest
   * @param response HttpResponse
   * @throws IOException If fails sending back to the user a proper response
   * @throws DotPublisherException If fails retrieving the Bundle related information like elements
   *     on it and statuses
   * @throws LanguageException If fails using i18 messages
   */
  public void retry(HttpServletRequest request, HttpServletResponse response)
      throws IOException, DotPublisherException, LanguageException {

    PublisherAPI publisherAPI = PublisherAPI.getInstance();
    PublishAuditAPI publishAuditAPI = PublishAuditAPI.getInstance();

    // Read the parameters
    String bundlesIds = request.getParameter("bundlesIds");
    String[] ids = bundlesIds.split(",");

    StringBuilder responseMessage = new StringBuilder();

    for (String bundleId : ids) {

      if (bundleId.trim().isEmpty()) {
        continue;
      }

      PublisherConfig basicConfig = new PublisherConfig();
      basicConfig.setId(bundleId);
      File bundleRoot = BundlerUtil.getBundleRoot(basicConfig);

      // Get the audit records related to this bundle
      PublishAuditStatus status = PublishAuditAPI.getInstance().getPublishAuditStatus(bundleId);
      String pojo_string = status.getStatusPojo().getSerialized();
      PublishAuditHistory auditHistory = PublishAuditHistory.getObjectFromString(pojo_string);

      // First we need to verify is this bundle is already in the queue job
      List<PublishQueueElement> foundBundles = publisherAPI.getQueueElementsByBundleId(bundleId);
      if (foundBundles != null && !foundBundles.isEmpty()) {
        appendMessage(responseMessage, "publisher_retry.error.already.in.queue", bundleId, true);
        continue;
      }

      // We will be able to retry failed and successfully bundles
      if (!(status.getStatus().equals(Status.FAILED_TO_PUBLISH)
          || status.getStatus().equals(Status.SUCCESS))) {
        appendMessage(responseMessage, "publisher_retry.error.only.failed.publish", bundleId, true);
        continue;
      }

      /*
      Verify if the bundle exist and was created correctly..., meaning, if there is not a .tar.gz file is because
      something happened on the creation of the bundle.
       */
      File bundleFile =
          new File(
              bundleRoot
                  + File.separator
                  + ".."
                  + File.separator
                  + basicConfig.getId()
                  + ".tar.gz");
      if (!bundleFile.exists()) {
        Logger.error(this.getClass(), "No Bundle with id: " + bundleId + " found.");
        appendMessage(responseMessage, "publisher_retry.error.not.found", bundleId, true);
        continue;
      }

      if (!BundlerUtil.bundleExists(basicConfig)) {
        Logger.error(
            this.getClass(), "No Bundle Descriptor for bundle id: " + bundleId + " found.");
        appendMessage(
            responseMessage, "publisher_retry.error.not.descriptor.found", bundleId, true);
        continue;
      }

      try {

        // Read the bundle to see what kind of configuration we need to apply
        String bundlePath = ConfigUtils.getBundlePath() + File.separator + basicConfig.getId();
        File xml = new File(bundlePath + File.separator + "bundle.xml");
        PushPublisherConfig config = (PushPublisherConfig) BundlerUtil.xmlToObject(xml);

        // We can not retry Received Bundles, just bundles that we are trying to send
        Boolean sending = sendingBundle(request, config, bundleId);
        if (!sending) {
          appendMessage(
              responseMessage, "publisher_retry.error.cannot.retry.received", bundleId, true);
          continue;
        }

        if (status.getStatus().equals(Status.SUCCESS)) {

          // Get the bundle
          Bundle bundle = APILocator.getBundleAPI().getBundleById(bundleId);
          if (bundle == null) {
            Logger.error(this.getClass(), "No Bundle with id: " + bundleId + " found.");
            appendMessage(responseMessage, "publisher_retry.error.not.found", bundleId, true);
            continue;
          }
          bundle.setForcePush(true);
          APILocator.getBundleAPI().updateBundle(bundle);
        }

        // Clean the number of tries, we want to try it again
        auditHistory.setNumTries(0);
        publishAuditAPI.updatePublishAuditStatus(
            config.getId(), status.getStatus(), auditHistory, true);

        // Get the identifiers on this bundle
        HashSet<String> identifiers = new HashSet<String>();
        List<PublishQueueElement> assets = config.getAssets();
        if (config.getLuceneQueries() != null && !config.getLuceneQueries().isEmpty()) {
          identifiers.addAll(PublisherUtil.getContentIds(config.getLuceneQueries()));
        }
        if (assets != null && !assets.isEmpty()) {
          for (PublishQueueElement asset : assets) {
            identifiers.add(asset.getAsset());
          }
        }

        // Now depending of the operation lets add it to the queue job
        if (config.getOperation().equals(PushPublisherConfig.Operation.PUBLISH)) {
          publisherAPI.addContentsToPublish(
              new ArrayList<String>(identifiers), bundleId, new Date(), getUser());
        } else {
          publisherAPI.addContentsToUnpublish(
              new ArrayList<String>(identifiers), bundleId, new Date(), getUser());
        }

        // Success...
        appendMessage(responseMessage, "publisher_retry.success", bundleId, false);
      } catch (Exception e) {
        Logger.error(
            this.getClass(),
            "Error trying to add bundle id: " + bundleId + " to the Publishing Queue.",
            e);
        appendMessage(responseMessage, "publisher_retry.error.adding.to.queue", bundleId, true);
      }
    }

    response.getWriter().println(responseMessage.toString());
  }