@Override
  public <E extends Event<ApplicationArchive>> void onBeforeOperation(
      E event, List<ProcessingEvent> events) throws EventNotificationException {

    ApplicationArchive archive = (ApplicationArchive) event.getPayload();
    boolean newUpload = archive.getNewFileUploaded() != null;
    ApplicationArchive ret = archive;
    if (newUpload && (ret = processApplicationArchiveFileUpload(archive, events)) == null) {
      throw new PersistenceException("Zip archive failed to process!");
    } else {
      event.setPayload(ret);
    }
  }
  @Override
  public <E extends Event<Map>> void handle(E event) throws EventHandlingException {

    if (logger.isTraceEnabled()) {
      logger.trace("entering handle()");
    }

    ApplicationArchive archive = (ApplicationArchive) event.getPayload().get("archive");
    File file = archive.getFile(getFileSystemStoragePathPrefix());

    if (file.exists()) {
      if (!file.delete()) {
        logger.error(
            "Failed to delete archive " + archive.getFile(getFileSystemStoragePathPrefix()));
      }
    } else {
      logger.warn(
          "Failed to find archive "
              + archive.getFile(getFileSystemStoragePathPrefix())
              + ".  It may have yet to be deployed.");
    }

    File directory = archive.getExplodedPath(getFileSystemStoragePathPrefix());
    if (directory.exists()) {
      try {
        FileUtils.deleteDirectory(directory);
      } catch (IOException ioe) {
        String msg = "Unable to delete directory " + directory;
        logger.error(msg);
        throw new EventHandlingException(msg, ioe);
      }
    }

    if (logger.isTraceEnabled()) {
      logger.trace("exiting handle()");
    }
  }
예제 #3
0
 @Override
 public List<ApplicationVersion> findVersionsByApplicationArchive(ApplicationArchive archive) {
   Query q =
       entityManager.createQuery(
           "select distinct av "
               + "from ApplicationVersion av "
               + "inner join fetch av.archive aa "
               + "where aa.id=:id ");
   q.setParameter("id", archive.getId());
   try {
     @SuppressWarnings(value = {"unchecked"})
     List<ApplicationVersion> versions = (List<ApplicationVersion>) q.getResultList();
     return versions;
   } catch (NoResultException nre) {
     return null;
   }
 }
예제 #4
0
 @Override
 public List<Deployment> findDeploymentsByApplicationArchive(ApplicationArchive archive) {
   Query q =
       entityManager.createQuery(
           "select distinct d "
               + "from Deployment d "
               + "inner join fetch d.applicationArchive aa "
               + "where aa.id=:id");
   q.setParameter("id", archive.getId());
   try {
     @SuppressWarnings(value = {"unchecked"})
     List<Deployment> deployments = (List<Deployment>) q.getResultList();
     return deployments;
   } catch (NoResultException nre) {
     return null;
   }
 }
  @SuppressWarnings("unchecked")
  private ApplicationArchive processApplicationArchiveFileUpload(
      ApplicationArchive archive, List<ProcessingEvent> events) {

    GlobalSettings settings = modelManager.getGlobalSettings();
    File tempFile = new File(archive.getNewFileUploaded());
    Long size = tempFile.length();

    String pathError = settings.validateTemporaryStoragePath();
    if (pathError != null) {
      logger.error(
          "There is an issue with the global settings temporary storage path: "
              + settings.validateTemporaryStoragePath()
              + "\n {}",
          pathError);
      events.add(
          new MessagesEvent(
              "There is an issue with the global settings temporary storage path: "
                  + settings.validateTemporaryStoragePath()
                  + " - "
                  + pathError));
      return null;
    }

    // determine the md5 hash of the uploaded file
    // and rename the temp file by the hash
    FileInputStream is = null;
    File destinationFile = null;
    try {

      // if the archive is pre-existing and not the same,
      // then determine if the web-view and zip should be deleted
      // that is, they are not used by any other versions
      if (archive.getId() != null) {
        ArchiveFileHelper.maintainFileSystemCleanliness(modelManager, fileManager, archive, events);
      }

      String hashValue = null;
      ApplicationArchive archiveExists = null;
      try {
        is = new FileInputStream(tempFile);
        hashValue = Utils.hashInputStream("MD5", is);
        archiveExists =
            modelManager
                .getModelService()
                .findApplicationArchiveByHashAndAlgorithm(
                    archive.getApplication(), hashValue, "MD5");
        if (archiveExists != null) {
          if (!tempFile.delete()) {
            String mesg = String.format("Failed to delete temporary file %s", tempFile.getName());
            logger.error(mesg);
            events.add(new MessagesEvent(mesg));
          }
          return archiveExists;
        } else {
          // if an archive of the hash/alg doesn't exist,
          // then we don't want to accidentally change an existing one.
          archive = archive.clone();
          archive.setId(null);
        }
      } catch (DigestException de) {
        throw new PersistenceException(de);
      } finally {
        is.close();
      }

      archive.setHashAlgorithm("MD5");
      archive.setHash(hashValue);

      destinationFile = archive.getFile(settings.getTemporaryStoragePath());

      // if the upload destination exists, then try to delete and overwrite
      // even though they are theoretically the same.
      if (destinationFile.exists() && !destinationFile.delete()) {
        String mesg =
            String.format(
                "Failed to delete old file (theoretically the same anyways, so proceeding) %s",
                destinationFile.getName());
        logger.error(mesg);
        events.add(new MessagesEvent(mesg));
        if (!tempFile.delete()) {
          mesg = String.format("Failed to delete temporary file %s", tempFile.getName());
          logger.error(mesg);
          events.add(new MessagesEvent(mesg));
        }
      }

      // if it didn't exist or it was successfully deleted,
      // then rename the upload to our destination and unzip it
      // into the web-view directory
      else if (tempFile.renameTo(destinationFile)) {

        String mesg =
            String.format(
                "Uploaded temporary file %s successfully renamed to %s",
                tempFile.getName(), destinationFile.getName());
        logger.debug(mesg);
        events.add(new MessagesEvent(mesg));
        ArchiveFileHelper.unzipFile(modelManager, fileManager, archive, destinationFile, events);
      } else {
        String mesg =
            String.format(
                "Failed to renamed file %s to %s", tempFile.getName(), destinationFile.getName());
        logger.error(mesg);
        events.add(new MessagesEvent(mesg));
        return null;
      }
    } catch (IOException ioe) {
      events.add(new MessagesEvent(ioe.getMessage()));
      return null;
    }

    // determine the compressed and uncompressed size of the zip archive
    try {
      archive.setBytesLength(size.intValue());
      ZipFile zipFile = null;
      try {
        zipFile = new ZipFile(destinationFile);
        Integer uncompressedSize = ZipUtils.getUncompressedSize(zipFile).intValue();
        archive.setBytesLengthUncompressed(new Long(uncompressedSize).intValue());
      } finally {
        if (zipFile != null) {
          zipFile.close();
        }
      }
    } catch (IOException ioe) {
      logger.error(
          "An exception occurred while calculating the uncompressed size of the archive: {}", ioe);
      events.add(
          new MessagesEvent(
              String.format(
                  "An exception occurred while calculating the uncompressed size of the archive: %s",
                  ioe.getMessage())));
      return null;
    }

    archive.setUrl(ApplicationArchive.URL_TEMPLATE);

    return archive;
  }