512 lines
16 KiB
Java
512 lines
16 KiB
Java
package org.gcube.portal.wssynclibrary.thredds;
|
|
|
|
import java.util.ArrayList;
|
|
import java.util.Collections;
|
|
import java.util.HashMap;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
import java.util.Set;
|
|
|
|
import org.gcube.portal.wssynclibrary.shared.ItemNotSynched;
|
|
import org.gcube.portal.wssynclibrary.shared.WorkspaceFolderLocked;
|
|
import org.gcube.portal.wssynclibrary.shared.thredds.Status;
|
|
import org.gcube.portal.wssynclibrary.shared.thredds.ThCatalogueBean;
|
|
import org.gcube.portal.wssynclibrary.shared.thredds.ThProcessDescriptor;
|
|
import org.gcube.portal.wssynclibrary.shared.thredds.ThProcessStatus;
|
|
import org.gcube.portal.wssynclibrary.shared.thredds.ThSyncElementInfo;
|
|
import org.gcube.portal.wssynclibrary.shared.thredds.ThSyncFolderDescriptor;
|
|
import org.gcube.portal.wssynclibrary.shared.thredds.ThSyncStatus;
|
|
import org.gcube.portal.wssynclibrary.shared.thredds.ThSynchFolderConfiguration;
|
|
import org.gcube.usecases.ws.thredds.SyncEngine;
|
|
import org.gcube.usecases.ws.thredds.engine.impl.ProcessDescriptor;
|
|
import org.gcube.usecases.ws.thredds.engine.impl.ProcessStatus;
|
|
import org.gcube.usecases.ws.thredds.faults.InternalException;
|
|
import org.gcube.usecases.ws.thredds.faults.ProcessNotFoundException;
|
|
import org.gcube.usecases.ws.thredds.faults.WorkspaceInteractionException;
|
|
import org.gcube.usecases.ws.thredds.faults.WorkspaceLockedException;
|
|
import org.gcube.usecases.ws.thredds.faults.WorkspaceNotSynchedException;
|
|
import org.gcube.usecases.ws.thredds.model.ContainerType;
|
|
import org.gcube.usecases.ws.thredds.model.SyncFolderDescriptor;
|
|
import org.gcube.usecases.ws.thredds.model.SyncOperationCallBack;
|
|
import org.gcube.usecases.ws.thredds.model.SynchFolderConfiguration;
|
|
import org.gcube.usecases.ws.thredds.model.SynchronizedElementInfo;
|
|
import org.gcube.usecases.ws.thredds.model.gui.CatalogBean;
|
|
import org.slf4j.Logger;
|
|
import org.slf4j.LoggerFactory;
|
|
|
|
// TODO: Auto-generated Javadoc
|
|
/**
|
|
* The Class WorkspaceThreddsSynchronize.
|
|
*
|
|
* @author Francesco Mangiacrapa francesco.mangiacrapa@isti.cnr.it Feb 14, 2018
|
|
*/
|
|
public class WorkspaceThreddsSynchronize
|
|
implements WorkspaceThreddsSynchronizedRepository<ThSyncStatus, ThSyncFolderDescriptor> {
|
|
|
|
/** The logger. */
|
|
private static Logger logger = LoggerFactory.getLogger(WorkspaceThreddsSynchronize.class);
|
|
|
|
/** The engine. */
|
|
private SyncEngine engine = null;
|
|
|
|
/** The instance. */
|
|
private static WorkspaceThreddsSynchronize instance = null;
|
|
|
|
/** The map call back. */
|
|
// Fully synchronized HashMap
|
|
private Map<String, ThSyncStatus> mapCallBack = Collections.synchronizedMap(new HashMap<>());
|
|
|
|
/**
|
|
* Instantiates a new workspace thredds synchronize.
|
|
*/
|
|
private WorkspaceThreddsSynchronize() {
|
|
// GET ENGINE : SINGLETON INSTANCE
|
|
engine = SyncEngine.get();
|
|
}
|
|
|
|
/**
|
|
* Gets the single instance of WorkspaceThreddsSynchronize.
|
|
*
|
|
* @return single instance of WorkspaceThreddsSynchronize
|
|
*/
|
|
public static WorkspaceThreddsSynchronize getInstance() {
|
|
if (instance == null) {
|
|
instance = new WorkspaceThreddsSynchronize();
|
|
}
|
|
return instance;
|
|
}
|
|
|
|
/**
|
|
* Check item synched.
|
|
*
|
|
* @param itemId the item id
|
|
* @return the th sync folder descriptor
|
|
* @throws ItemNotSynched the item not synched
|
|
* @throws WorkspaceFolderLocked the workspace folder locked
|
|
* @throws Exception the exception
|
|
*/
|
|
@Override
|
|
public ThSyncFolderDescriptor checkItemSynched(String itemId)
|
|
throws ItemNotSynched, WorkspaceFolderLocked, Exception {
|
|
logger.debug("Perfoming checkItemSynched for id: " + itemId);
|
|
try {
|
|
// WHEN OPENING A FOLDER, INVOKE CHECK TO UPDATE SYNCH STATUS
|
|
SyncFolderDescriptor desc = engine.check(itemId, false);
|
|
|
|
logger.debug("The item id: " + itemId + " is synched");
|
|
ThSyncFolderDescriptor descr = ThreddsConverter.toThSyncFolderDescriptor.apply(desc);
|
|
logger.trace("CheckItemSynched for id: " + itemId + " returning descriptor: " + descr);
|
|
return descr;
|
|
|
|
} catch (WorkspaceNotSynchedException e) {
|
|
String err = "The item id: " + itemId + " is not synched";
|
|
logger.trace(err);
|
|
throw new ItemNotSynched("The item id: " + itemId + " is not synched");
|
|
// System.out.println("Folder not synched, configurin it..");
|
|
// engine.setSynchronizedFolder(config, folder.getId());
|
|
} catch (WorkspaceLockedException e) {
|
|
// logger.warn("Workspace locked, going to force unlock..");
|
|
throw new WorkspaceFolderLocked(itemId,
|
|
"The folder id: " + itemId + " is currently locked. Another sync process is in progress");
|
|
// engine.forceUnlock(itemId);
|
|
} catch (WorkspaceInteractionException | InternalException e) {
|
|
logger.error("Error: ", e);
|
|
if (e instanceof WorkspaceInteractionException)
|
|
throw new Exception(
|
|
"Sorry, a WorkspaceInteraction error occurred during check syncronization for the itemId: "
|
|
+ itemId+". Try again or contact the support");
|
|
else if (e instanceof InternalException)
|
|
throw new Exception(
|
|
"Sorry, an Internal error occurred during check syncronization for the itemId: " + itemId+". Try again or contact the support");
|
|
|
|
throw new Exception(
|
|
"Sorry, an error occurred server side during chck syncronization for the itemId: " + itemId+". Try again or contact the support");
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Sets the synchronized folder.
|
|
*
|
|
* @param thConfig the th config
|
|
* @param itemId the item id
|
|
* @return the th sync folder descriptor
|
|
* @throws Exception the exception
|
|
*/
|
|
public ThSyncFolderDescriptor setSynchronizedFolder(ThSynchFolderConfiguration thConfig, String itemId)
|
|
throws Exception {
|
|
SynchFolderConfiguration config = ThreddsConverter.toSynchFolderConfiguration.apply(thConfig);
|
|
|
|
if (thConfig.getRemotePath() == null || thConfig.getRemotePath().isEmpty())
|
|
throw new Exception("A valid remote path must be provided");
|
|
|
|
if (thConfig.getToCreateCatalogName() == null || thConfig.getToCreateCatalogName().isEmpty())
|
|
throw new Exception("A valid Catalogue Name must be provided");
|
|
|
|
try {
|
|
engine.setSynchronizedFolder(config, itemId);
|
|
} catch (WorkspaceInteractionException | InternalException e) {
|
|
logger.error("Error on setSynchronizedFolder for config: " + thConfig);
|
|
logger.error("Using itemId: " + itemId, e);
|
|
throw new Exception("Error on setSynchronizedFolder");
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Do sync.
|
|
*
|
|
* @param itemId the item id
|
|
* @return the th sync status
|
|
* @throws Exception the exception
|
|
*/
|
|
@Override
|
|
public ThSyncStatus doSync(String itemId) throws Exception {
|
|
|
|
try {
|
|
// INVOKE SYNCHRONIZATION ON FOLDER
|
|
ProcessDescriptor descriptor = engine.doSync(itemId);
|
|
ThSyncStatus synStatus = mapCallBack.get(itemId);
|
|
|
|
if (synStatus == null) {
|
|
|
|
registerCallbackForId(itemId);
|
|
descriptor = engine.getProcessDescriptorByFolderId(itemId);
|
|
ProcessStatus status = engine.getProcessStatusByFolderId(itemId);
|
|
updateMapCallback(itemId, status, descriptor);
|
|
}
|
|
|
|
logger.debug("DoSync returning status: " + synStatus);
|
|
return synStatus;
|
|
|
|
} catch (WorkspaceInteractionException | InternalException | ProcessNotFoundException e) {
|
|
logger.error("DoSync Error: ", e);
|
|
throw e;
|
|
}
|
|
|
|
}
|
|
|
|
/**
|
|
* Monitor sync status.
|
|
*
|
|
* @param itemId the item id
|
|
* @return the th sync status
|
|
* @throws ItemNotSynched the item not synched
|
|
* @throws Exception the exception
|
|
*/
|
|
@Override
|
|
public ThSyncStatus monitorSyncStatus(String itemId) throws ItemNotSynched, Exception {
|
|
|
|
try {
|
|
|
|
ThSyncStatus synStatus = mapCallBack.get(itemId);
|
|
if (synStatus == null) {
|
|
try {
|
|
|
|
registerCallbackForId(itemId);
|
|
ProcessDescriptor descriptor = engine.getProcessDescriptorByFolderId(itemId);
|
|
ProcessStatus status = engine.getProcessStatusByFolderId(itemId);
|
|
updateMapCallback(itemId, status, descriptor);
|
|
ThSyncStatus thSyncStatus = mapCallBack.get(itemId);
|
|
|
|
if (thSyncStatus == null)
|
|
throw new Exception("No sync status found for item id: " + itemId);
|
|
|
|
return thSyncStatus;
|
|
|
|
} catch (ProcessNotFoundException e) {
|
|
throw new Exception(
|
|
"Monitor is not available here. The sync process is in progress on another machine");
|
|
}
|
|
}
|
|
|
|
if (synStatus.getProcessStatus() != null) {
|
|
if (synStatus.getProcessStatus().getStatus() != null) {
|
|
if (synStatus.getProcessStatus().getStatus().equals(Status.COMPLETED)) {
|
|
// TODO NOW?
|
|
mapCallBack.put(itemId, null);
|
|
}
|
|
}
|
|
}
|
|
|
|
logger.trace("MonitorSyncStatus for item: " + itemId + " returning: " + synStatus);
|
|
return synStatus;
|
|
|
|
} catch (Exception e) {
|
|
throw new Exception("Sorry, an error occurred during getting sync status for itemId: " + itemId, e);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Register callback for id.
|
|
*
|
|
* @param itemId the item id
|
|
* @throws ProcessNotFoundException the process not found exception
|
|
* @throws Exception the exception
|
|
*/
|
|
@Override
|
|
public void registerCallbackForId(String itemId) throws ProcessNotFoundException, Exception {
|
|
|
|
try {
|
|
|
|
SyncOperationCallBack callback = new SyncOperationCallBack() {
|
|
|
|
@Override
|
|
public void onStep(ProcessStatus status, ProcessDescriptor descriptor) {
|
|
logger.debug("ON STEP : " + status + " " + descriptor);
|
|
logger.debug("LOG : \n" + status.getLogBuilder().toString());
|
|
if (status.getStatus().equals(ProcessStatus.Status.COMPLETED)) {
|
|
// mapCallBack.remove(itemId);
|
|
}
|
|
updateMapCallback(itemId, status, descriptor);
|
|
}
|
|
};
|
|
|
|
// REGISTER CALLBACK TO MONITOR PROGRESS
|
|
logger.debug("Registering callback for itemId: " + itemId);
|
|
engine.registerCallBack(itemId, callback);
|
|
} catch (ProcessNotFoundException e) {
|
|
logger.error("Register callback for id: " + itemId + " threw ProcessNotFoundException: ", e);
|
|
throw e;
|
|
} catch (Exception e) {
|
|
logger.error("Register callback exception: ", e);
|
|
throw new Exception("An error occurred on registering callback for: " + itemId, e);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Update map callback.
|
|
*
|
|
* @param itemId the item id
|
|
* @param status the status
|
|
* @param descriptor the descriptor
|
|
*/
|
|
private void updateMapCallback(String itemId, ProcessStatus status, ProcessDescriptor descriptor) {
|
|
ThProcessDescriptor thDesc = ThreddsConverter.toThProcessDescriptor.apply(descriptor);
|
|
ThProcessStatus thStatus = ThreddsConverter.toThProcessStatus.apply(status);
|
|
mapCallBack.put(itemId, new ThSyncStatus(thDesc, thStatus));
|
|
logger.debug("Update map for " + itemId + " with new " + thStatus);
|
|
}
|
|
|
|
/**
|
|
* Gets the available catalogues. you need to set the context caller.
|
|
*
|
|
* @return the available catalogues
|
|
* @throws Exception the exception
|
|
*/
|
|
public List<ThCatalogueBean> getAvailableCatalogues() throws Exception {
|
|
logger.debug("called Get Available Catalogues");
|
|
Set<CatalogBean> ctlgs = engine.getAvailableCatalogs();
|
|
|
|
if (ctlgs == null || ctlgs.size() == 0) {
|
|
logger.info("No Catalogue available in the current context, returning empty list");
|
|
return new ArrayList<ThCatalogueBean>(1);
|
|
}
|
|
|
|
List<ThCatalogueBean> listCtlgs = new ArrayList<ThCatalogueBean>(ctlgs.size());
|
|
for (CatalogBean bean : ctlgs) {
|
|
logger.debug(bean.getName() + " in " + bean.getPath() + " Default : " + bean.getIsDefault());
|
|
ThCatalogueBean toBean = ThreddsConverter.toThCatalogueBean.apply(bean);
|
|
if (toBean != null)
|
|
listCtlgs.add(toBean);
|
|
}
|
|
|
|
Collections.sort(listCtlgs);
|
|
logger.info("Returning sorted Catalogue list with: " + listCtlgs.size() + " item/s");
|
|
return listCtlgs;
|
|
}
|
|
|
|
/**
|
|
* Do un sync.
|
|
*
|
|
* @param itemId the item id
|
|
* @param deleteRemoteContent the delete remote content
|
|
* @return the boolean
|
|
* @throws Exception the exception
|
|
*/
|
|
@Override
|
|
public Boolean doUnSync(String itemId, boolean deleteRemoteContent) throws Exception {
|
|
|
|
if (itemId == null)
|
|
throw new Exception("Invalid parameter: itemId is null");
|
|
|
|
try {
|
|
engine.unsetSynchronizedFolder(itemId, deleteRemoteContent);
|
|
return true;
|
|
} catch (Exception e) {
|
|
logger.error("Unset Syncronized folder exception: ", e);
|
|
throw new Exception("An error occurred on deleting configuration to the item id: " + itemId, e);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Gets the configuration.
|
|
*
|
|
* @param itemId the item id
|
|
* @return the configuration
|
|
* @throws WorkspaceInteractionException the workspace interaction exception
|
|
* @throws WorkspaceNotSynchedException the workspace not synched exception
|
|
* @throws Exception the exception
|
|
*
|
|
* NB. it is time consuming due to it
|
|
* calls the SHUB
|
|
*/
|
|
@Override
|
|
public ThSyncFolderDescriptor getConfiguration(String itemId)
|
|
throws WorkspaceInteractionException, WorkspaceNotSynchedException, Exception {
|
|
|
|
if (itemId == null)
|
|
throw new Exception("Invalid parameter: itemId is null");
|
|
|
|
SynchFolderConfiguration syncFolderConfig = engine.getConfig(itemId);
|
|
ThSynchFolderConfiguration toFolderConfig = ThreddsConverter.toThSynchFolderConfiguration
|
|
.apply(syncFolderConfig);
|
|
|
|
return new ThSyncFolderDescriptor(itemId, null, toFolderConfig, false, null, null);
|
|
|
|
}
|
|
|
|
/**
|
|
* Gets the element info.
|
|
*
|
|
* @param itemProperties the item properties read from SHUB by accessing to
|
|
* Metadata.Map() of a item
|
|
* @param itemType the item type
|
|
* @return the element info
|
|
* @throws WorkspaceNotSynchedException the workspace not synched exception
|
|
*/
|
|
public ThSyncElementInfo getElementInfo(Map<String, Object> itemProperties, ContainerType itemType)
|
|
throws WorkspaceNotSynchedException {
|
|
|
|
if (itemProperties == null || itemProperties.isEmpty())
|
|
return null;
|
|
|
|
SynchronizedElementInfo theSEI = SyncEngine.parseInfo(itemProperties, itemType);
|
|
logger.debug("the SynchronizedElementInfo returned is: "+theSEI);
|
|
return ThreddsConverter.toThSyncElementInfo.apply(theSEI);
|
|
|
|
}
|
|
|
|
/**
|
|
* Checks if is item synched. This calls the {@link SyncEngine#parseInfo(Map, ContainerType)}
|
|
*
|
|
* @param itemId the item id
|
|
* @param itemProperties the item properties
|
|
* @param itemType the item type
|
|
* @return true, if is item synched
|
|
*/
|
|
public boolean isItemSynched(String itemId, Map<String, Object> itemProperties, ContainerType itemType) {
|
|
|
|
ThSyncElementInfo sinInfo = null;
|
|
try {
|
|
sinInfo = getElementInfo(itemProperties, itemType);
|
|
} catch (WorkspaceNotSynchedException e) {
|
|
logger.debug("WorkspaceNotSynchedException catched, the item id: " + itemId + " is not synched");
|
|
} catch (Exception e) {
|
|
logger.debug("Error on getting SyncElementInfo for the item id: " + itemId
|
|
+ ", returning null (means not synched)", e);
|
|
}
|
|
|
|
if (sinInfo != null)
|
|
return true;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
/*
|
|
* (non-Javadoc)
|
|
*
|
|
* @see
|
|
* org.gcube.portal.wssynclibrary.WorkspaceSynchronizedRepository#removeSync(
|
|
* java.lang.String)
|
|
*/
|
|
/**
|
|
* Removes the sync.
|
|
*
|
|
* @param itemId the item id
|
|
* @return the boolean
|
|
* @throws Exception the exception
|
|
*/
|
|
@Override
|
|
public Boolean removeSync(String itemId) throws Exception {
|
|
throw new Exception("removeSync not implemented");
|
|
}
|
|
|
|
/*
|
|
* (non-Javadoc)
|
|
*
|
|
* @see
|
|
* org.gcube.portal.wssynclibrary.WorkspaceSynchronizedRepository#stopSync(java.
|
|
* lang.String)
|
|
*/
|
|
/**
|
|
* Stop sync.
|
|
*
|
|
* @param itemId the item id
|
|
* @return the boolean
|
|
* @throws Exception the exception
|
|
*/
|
|
@Override
|
|
public Boolean stopSync(String itemId) throws Exception {
|
|
throw new Exception("stopSync not implemented");
|
|
}
|
|
|
|
/*
|
|
* (non-Javadoc)
|
|
*
|
|
* @see
|
|
* org.gcube.portal.wssynclibrary.WorkspaceSynchronizedRepository#initRepository
|
|
* ()
|
|
*/
|
|
/**
|
|
* Inits the repository.
|
|
*
|
|
* @return the boolean
|
|
* @throws Exception the exception
|
|
*/
|
|
@Override
|
|
public Boolean initRepository() throws Exception {
|
|
throw new Exception("initRepository not implemented");
|
|
}
|
|
|
|
/*
|
|
* (non-Javadoc)
|
|
*
|
|
* @see org.gcube.portal.wssynclibrary.WorkspaceSynchronizedRepository#
|
|
* shutDownRepository()
|
|
*/
|
|
/**
|
|
* Shut down repository.
|
|
*
|
|
* @return the boolean
|
|
*/
|
|
@Override
|
|
public Boolean shutDownRepository() {
|
|
try {
|
|
engine.shutDown();
|
|
return true;
|
|
} catch (Exception e) {
|
|
return null;
|
|
}
|
|
|
|
}
|
|
|
|
/*
|
|
* (non-Javadoc)
|
|
*
|
|
* @see
|
|
* org.gcube.portal.wssynclibrary.thredds.WorkspaceThreddsSynchronizedRepository
|
|
* #decribeSyncRepository()
|
|
*/
|
|
/**
|
|
* Decribe sync repository.
|
|
*
|
|
* @return the string
|
|
*/
|
|
@Override
|
|
public String decribeSyncRepository() {
|
|
return "Sync repository for Thredds";
|
|
}
|
|
|
|
}
|