ReceivedPreparedPackagesHandler

package com.trendmicro.grid.acl.ds.jpa;

import com.trendmicro.grid.acl.ds.jpa.entities.*;
import com.trendmicro.grid.acl.l0.datatypes.*;
import com.trendmicro.grid.acl.metadata.Meta;
import com.trendmicro.grid.acl.metadata.Metadata;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.net.URI;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Iterator;

import static com.trendmicro.grid.acl.ds.jpa.ReceivedPreparedPackagesHandler.PreparedPackage;

/**
 * Manages updates to PACKAGES & HISTORY table.
 *
 * @author juergen_kellerer, 2010-11-22
 * @version 1.0
 */
public class ReceivedPreparedPackagesHandler extends AbstractReceivedFileContentsHandler<Collection<PreparedPackage>> {

	private static final Logger log = LoggerFactory.getLogger(ReceivedPreparedPackagesHandler.class);

	private final JpaPackageRepository packageRepository;

	private final AbstractReceivedResultsHandler<Collection<JpaPackageFamily>> familyHandler;

	/**
	 * Creates a new thread safe instance.
	 *
	 * @param fileRepository    the repository to use for file contents.
	 * @param packageRepository the repository to use for packages.
	 * @param familyHandler     the FamilyHandler to use.
	 */
	public ReceivedPreparedPackagesHandler(JpaFileRepository fileRepository, JpaPackageRepository packageRepository,
	                                       AbstractReceivedResultsHandler<Collection<JpaPackageFamily>> familyHandler) {
		super(fileRepository);
		this.familyHandler = familyHandler;
		this.packageRepository = packageRepository;
	}

	/**
	 * {@inheritDoc}
	 */
	@Override
	protected Collection<PreparedPackage> handle(StorageContext context) {
		final Iterator<JpaPackageFamily> familyRefs = familyHandler.handle(context).iterator();

		Collection<PreparedPackage> preparedPackages = new ArrayList<PreparedPackage>(context.receivedDataSets.size());
		for (ProcessPackageDataSet dataSet : context.receivedDataSets) {
			// We must flush here to ensure history revisions are updated before queried.
			context.em.flush();
			preparedPackages.add(preparedPackage(context, familyRefs.next(), dataSet));
		}

		return preparedPackages;
	}

	/**
	 * Manages updates to PACKAGES & HISTORY table.
	 *
	 * @param context         the context for the current transaction.
	 * @param familyReference the reference to the package family.
	 * @param dataSet         the element describing the package.
	 * @return A PreparedPackage instance or 'null' if no further operation should be performed on the package.
	 */
	PreparedPackage preparedPackage(final StorageContext context,
	                                final JpaPackageFamily familyReference,
	                                final ProcessPackageDataSet dataSet) {

		final PackageDetails packageDetails = dataSet.getProcessedPackage();
		final JpaFileDetails fileDetailsReference = createOrUpdateFileReference(context, packageDetails);

		final PackageInformation information = packageDetails.getPackageInformation();
		final String packageName = information.getName();

		JpaPackageDetails existingDetails = packageRepository.getJpaPackageDetailsListByName(
				Collections.singleton(packageName)).iterator().next();
		final boolean isNewPackage = existingDetails == null;

		// Handle updates to PACKAGES and PACKAGE_HISTORY
		if (isNewPackage) {
			final String[] tags = information.getTags().toArray(new String[information.getTags().size()]);

			JpaPackageInformation jpaInformation = new JpaPackageInformation(
					information.getName(), information.getDisplayName(),
					information.getFamilyName(), information.getVendorName(),
					tags, fileDetailsReference.getInformation());

			existingDetails = new JpaPackageDetails(familyReference, jpaInformation,
					packageDetails.getMetadata(), fileDetailsReference);

			if (log.isTraceEnabled()) {
				log.trace("Storing new package '{}', tagged as '{}'",
						information.getName(), existingDetails.getPackageInformation().getTags());
			}

			context.em.persist(existingDetails);

		} else {
			if (context.ignoreAllUpdates) {
				if (log.isTraceEnabled()) {
					log.trace("Not further processing package '{}', " +
							"updates are generally disabled.", information.getName());
				}
				return null;
			}

			// Make sure we have the revision aligned with the session before we apply further updates.
			if (context.enableHistoryRecording) existingDetails.alignRevisionWithSession(context.em);

			// TODO: What to do when the "existingFileDetails#primaryKey" changed.
			// TODO: (Handle at least the history updates in the next version of ACL!)
			if (existingDetails.getPackageFileDetails().getPrimaryKey() != fileDetailsReference.getPrimaryKey()) {
				log.warn("TMACL-01840:The previously stored package named '{}' was reprocessed with a different " +
						"package file than before identifier was {}, but is now {}. The change is applied but the " +
						"current ACL version doesn't support to record this in the history table.", new Object[]{
						packageName, existingDetails.getPackageFileDetails().getIdentifier(),
						fileDetailsReference.getIdentifier()});
			}

			// Setting the new or updated file details reference to ensure we have update internal
			// data structures inside the package details.
			existingDetails.setPackageFileDetails(fileDetailsReference);
			if(!familyReference.equals(existingDetails.getPackageFamily()))
				existingDetails.setPackageFamily(familyReference);
		}

		return new PreparedPackage(context, packageDetails, existingDetails,
				fileDetailsReference, extractPackageRemoteFilename(dataSet), isNewPackage);
	}


	private JpaFileDetails createOrUpdateFileReference(final StorageContext context, final PackageDetails details) {
		return createOrUpdateFileReference(context, new FileDetails(
				details.getFileMetadata().getIdentifier(),
				details.getPackageInformation().getPackageFileInformation(),
				details.getFileMetadata().getMetadata()), true
		);
	}


	private String extractPackageRemoteFilename(ProcessPackageDataSet dataSet) {
		// Guesses the filename as it was used on the remote side by evaluating the sources.
		String fileName = "";
		Collection<Source> sources = dataSet.getProcessSources();
		if (sources != null && !sources.isEmpty()) {
			Source mainSource = sources.iterator().next();
			URI remoteURI = mainSource.getRemoteURI();
			if (remoteURI != null) {
				fileName = remoteURI.getPath() == null ? "" : remoteURI.getPath();
				fileName = fileName.substring(fileName.lastIndexOf('/') + 1);
			}

			final Metadata sourceMetadata = mainSource.getMetadata();
			if (sourceMetadata != null)
				for (String key : StorageOptions.META_FILENAME_KEYS) {
					Meta m = sourceMetadata.get(key);
					if (m != null) {
						String fn = m.getValue();
						if (fn != null && fn.indexOf('.') != -1)
							fileName = fn;
					}
				}
		}
		return fileName;
	}


	/**
	 * Defines a prepared package that may be used for further updates.
	 */
	public static final class PreparedPackage {

		private final StorageContext context;
		private final PackageDetails updatedDetails;
		private final JpaPackageDetails reference;
		private final JpaFileDetails fileReference;
		private final String remoteFileName;
		private final boolean isNew;

		private PreparedPackage(StorageContext context, PackageDetails updatedDetails, JpaPackageDetails reference,
		                        JpaFileDetails fileReference, String remoteFileName, boolean isNew) {
			this.context = context;
			this.updatedDetails = updatedDetails;
			this.reference = reference;
			this.fileReference = fileReference;
			this.remoteFileName = remoteFileName;

			this.isNew = isNew;
		}

		/**
		 * Returns the package reference to link other resources.
		 *
		 * @return the package reference to link other resources.
		 */
		public JpaPackageDetails getReference() {
			return reference;
		}

		/**
		 * Returns the reference to the package file.
		 *
		 * @return the reference to the package file.
		 */
		public JpaFileDetails getFileReference() {
			return fileReference;
		}

		/**
		 * Returns the recorded public filename of the assigned file for this package.
		 *
		 * @return the recorded public filename of the assigned file for this package.
		 */
		public String getRemoteFileName() {
			return remoteFileName;
		}

		/**
		 * Performs a final package update and optionally forces the increment of the revision.
		 * <p/>
		 * Note: This method must be called on every PreparedPackage instance before leaving
		 * the transaction scope.
		 *
		 * @param incrementRevision forces the increment of the revision when set to true.
		 */
		public void applyFinalPackageUpdates(boolean incrementRevision) {
			final PackageInformation information = updatedDetails.getPackageInformation();
			final Metadata metadata = updatedDetails.getMetadata();
			final boolean ignoreMetadata = context.ignoreNullMetadataUpdates && isNull(metadata);

			if (!isNew && JpaPackageHistory.wasChanged(reference, updatedDetails, ignoreMetadata)) {
				if (log.isTraceEnabled())
					log.trace("Updating package-content to: {}", updatedDetails);

				JpaPackageHistory history = new JpaPackageHistory(reference);

				//If disabled, recording of data in the database are ignored. Default is enabled
				if (context.enableHistoryRecording) {
					if (log.isTraceEnabled())
						log.trace("Storing new package-content history entry: {}", history);
					context.em.persist(history);
				} else {
					if (log.isTraceEnabled())
						log.trace("enableHistoryRecording is set to {}. Disregarding package-content history entry: {}", context.enableHistoryRecording, history);
				}

				final JpaPackageInformation existingInformation = reference.getPackageInformation();
				reference.setMetadata(metadata);
				existingInformation.setDisplayName(information.getDisplayName());
				existingInformation.setTags(information.getTags());

			} else if (incrementRevision) {
				reference.setRevision(reference.getRevision() + 1);

				if (log.isTraceEnabled()) {
					log.trace("Incremented package revision inside '{}' " +
							"after a change in the file assignments.", reference);
				}
			}
		}
	}
}