prerna.reactor.utils.DeleteEngineReactor Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of semoss Show documentation
SEMOSS
The newest version!
package prerna.reactor.utils;

import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;

import prerna.auth.User;
import prerna.auth.utils.AbstractSecurityUtils;
import prerna.auth.utils.SecurityAdminUtils;
import prerna.auth.utils.SecurityEngineUtils;
import prerna.auth.utils.SecurityQueryUtils;
import prerna.auth.utils.WorkspaceAssetUtils;
import prerna.cluster.util.ClusterUtil;
import prerna.cluster.util.DeleteEngineRunner;
import prerna.engine.api.IEngine;
import prerna.masterdatabase.DeleteFromMasterDB;
import prerna.reactor.AbstractReactor;
import prerna.sablecc2.om.GenRowStruct;
import prerna.sablecc2.om.PixelDataType;
import prerna.sablecc2.om.PixelOperationType;
import prerna.sablecc2.om.ReactorKeysEnum;
import prerna.sablecc2.om.nounmeta.NounMetadata;
import prerna.usertracking.UserTrackingUtils;
import prerna.util.Constants;
import prerna.util.EngineSyncUtility;
import prerna.util.EngineUtility;
import prerna.util.UploadUtilities;
import prerna.util.Utility;

public class DeleteEngineReactor extends AbstractReactor {

	private static final Logger classLogger = LogManager.getLogger(DeleteEngineReactor.class);

	public DeleteEngineReactor() {
		this.keysToGet = new String[] { ReactorKeysEnum.ENGINE.getKey() };
	}

	@Override
	public NounMetadata execute() {
		List engineIds = getEngineIds();
		// first validate all the inputs
		User user = this.insight.getUser();
		boolean isAdmin = SecurityAdminUtils.userIsAdmin(user);
		if(!isAdmin) {
			for (String engineId : engineIds) {
				if(AbstractSecurityUtils.adminOnlyEngineDelete(engineId)) {
					throwFunctionalityOnlyExposedForAdminsError();
				}
				
				if(WorkspaceAssetUtils.isAssetOrWorkspaceProject(engineId)) {
					throw new IllegalArgumentException("Users are not allowed to delete your workspace or asset database.");
				}
				// we may have the alias
				engineId = SecurityQueryUtils.testUserEngineIdForAlias(this.insight.getUser(), engineId);
				boolean isOwner = SecurityEngineUtils.userIsOwner(user, engineId);
				if(!isOwner) {
					throw new IllegalArgumentException("Engine " + engineId + " does not exist or user does not have permissions to delete the engine. User must be the owner to perform this function.");
				}
			} 
		}
		
		// once all are good, we can delete
		for (String engineId : engineIds) {
			// we may have the alias
			engineId = SecurityQueryUtils.testUserEngineIdForAlias(this.insight.getUser(), engineId);
			IEngine engine = Utility.getEngine(engineId, false);
			String engineName = null;
			IEngine.CATALOG_TYPE engineType = null;
			if(engine != null) {
				engineName = engine.getEngineName();
				engineType = engine.getCatalogType();
			} else {
				engineName = SecurityEngineUtils.getEngineAliasForId(engineId);
				Object[] typeAndSubtype = SecurityEngineUtils.getEngineTypeAndSubtype(engineId);
				engineType = (IEngine.CATALOG_TYPE) typeAndSubtype[0];
			}
			
			deleteEngines(engine, engineId, engineName, engineType);
			EngineSyncUtility.clearEngineCache(engineId);
			UserTrackingUtils.deleteEngine(engineId);
			// Run the delete thread in the background for removing from cloud storage
			if (ClusterUtil.IS_CLUSTER) {
				Thread deleteAppThread = new Thread(new DeleteEngineRunner(engineId, engineType));
				deleteAppThread.start();
			}
		}
		
		return new NounMetadata(true, PixelDataType.BOOLEAN, PixelOperationType.DELETE_ENGINE);
	}

	/**
	 * 
	 * @param engine
	 * @return
	 */
	private boolean deleteEngines(IEngine engine, String engineId, String engineName, IEngine.CATALOG_TYPE engineType) {
		UploadUtilities.removeEngineFromDIHelper(engineId);
		// remove from local master if database
		if(IEngine.CATALOG_TYPE.DATABASE == engineType) {
			DeleteFromMasterDB remover = new DeleteFromMasterDB();
			remover.deleteEngineRDBMS(engineId);
		}
		// remove from security
		SecurityEngineUtils.deleteEngine(engineId);
		// remove from user tracking
		UserTrackingUtils.deleteEngine(engineId);
		
		// now try to actually remove from disk
		if(engine != null) {
			try {
				engine.delete();
			} catch (IOException e) {
				classLogger.error(Constants.STACKTRACE, e);
			}
		} else {
			// try to delete based on the name of the folder and smss file
			// which we expect to be based on enginename__engineid
			String thisEngineFolder = EngineUtility.getSpecificEngineVersionFolder(engineType, engineId, engineName);
			File thisEngineF = new File(thisEngineFolder);
			if(thisEngineF.exists() && thisEngineF.isDirectory()) {
				thisEngineF.delete();
			}
			String smssFile = thisEngineFolder+".smss";
			File thisSmssF = new File(smssFile);
			if(thisSmssF.exists() && thisSmssF.isFile()) {
				thisSmssF.delete();
			}
		}
		
		return true;
	}

	/**
	 * Get inputs
	 * @return list of engines to delete
	 */
	public List getEngineIds() {
		List engineIds = new ArrayList<>();

		// see if added as key
		GenRowStruct grs = this.store.getNoun(this.keysToGet[0]);
		if (grs != null && !grs.isEmpty()) {
			int size = grs.size();
			for (int i = 0; i < size; i++) {
				engineIds.add(grs.get(i).toString());
			}
			return engineIds;
		}

		// no key is added, grab all inputs
		int size = this.curRow.size();
		for (int i = 0; i < size; i++) {
			engineIds.add(this.curRow.get(i).toString());
		}
		return engineIds;
	}
}