/** {@inheritDoc} */
@MethodLog
public StorageData removeLabelFromStorage(
StorageData storageData, AbstractStorageLabel<?> storageLabel) throws StorageException {
try {
storageManager.removeLabelFromStorage(storageData, storageLabel);
return storageManager.getStorageData(storageData.getId());
} catch (IOException | SerializationException e) {
throw new StorageException(
"Exception occurred trying to save storage data changes to disk.", e);
}
}
/** {@inheritDoc} */
@MethodLog
public String getCachedStorageDataFileLocation(StorageData storageData, int hash)
throws StorageException {
if (!storageManager.isStorageExisting(storageData)) {
throw new StorageException(
"The storage "
+ storageData
+ " does not exist on the CMR. Cached data file can not be resolved.");
}
return storageManager.getCachedStorageDataFileLocation(storageData, hash);
}
/**
* Opens an already existing storage in means that it prepares it for write.
*
* @param storageData Storage to open.
* @throws StorageException When storage with provided {@link StorageData} does not exists. When
* storage opening fails.
*/
@MethodLog
public void openStorage(StorageData storageData) throws StorageException {
if (!storageManager.isStorageExisting(storageData)) {
throw new StorageException("The storage " + storageData + " does not exsist on the CMR.");
}
try {
storageManager.openStorage(storageData);
} catch (Exception e) {
throw new StorageException(
"Exception occurred trying to open storage" + storageData + ".", e);
}
}
/** {@inheritDoc} */
@MethodLog
public StorageData addLabelToStorage(
StorageData storageData, AbstractStorageLabel<?> storageLabel, boolean doOverwrite)
throws StorageException {
try {
storageManager.addLabelToStorage(storageData, storageLabel, doOverwrite);
storageLabelDataDao.saveLabel(storageLabel);
return storageManager.getStorageData(storageData.getId());
} catch (IOException | SerializationException e) {
throw new StorageException(
"Exception occurred trying to save storage data changes to disk.", e);
}
}
/** {@inheritDoc} */
@MethodLog
public Map<String, Long> getAgentFilesLocations(StorageData storageData) throws StorageException {
if (!storageManager.isStorageExisting(storageData)) {
throw new StorageException("The storage " + storageData + " does not exist on the CMR.");
}
try {
return storageManager.getFilesHttpLocation(
storageData, StorageFileType.AGENT_FILE.getExtension());
} catch (IOException e) {
throw new StorageException(
"Exception occurred trying to load storage agent files locations.", e);
}
}
/** {@inheritDoc} */
@MethodLog
public void stopRecording() throws StorageException {
try {
storageManager.stopRecording();
} catch (Exception e) {
throw new StorageException("Exception occurred trying to stop recording.", e);
}
}
/** {@inheritDoc} */
@MethodLog
public void updateStorageData(StorageData storageData) throws StorageException {
try {
storageManager.updateStorageData(storageData);
} catch (IOException | SerializationException e) {
throw new StorageException(e);
}
}
/** {@inheritDoc} */
@MethodLog
public void unpackUploadedStorage(IStorageData storageData) throws StorageException {
try {
storageManager.unpackUploadedStorage(storageData);
} catch (IOException e) {
throw new StorageException("Exception occurred trying to check for imported storage.", e);
}
}
/** {@inheritDoc} */
@MethodLog
public void writeToStorage(
StorageData storageData,
Collection<DefaultData> defaultDataCollection,
Collection<AbstractDataProcessor> dataProcessors,
boolean synchronously)
throws StorageException {
if (!storageManager.isStorageOpen(storageData)) {
throw new StorageException(
"Writing to storage tried to be performed on the storage that is not opened. Please open the storage first.");
}
try {
storageManager.writeToStorage(
storageData, defaultDataCollection, dataProcessors, synchronously);
} catch (IOException | SerializationException e) {
throw new StorageException("Copy Buffer to Storage action encountered an error.", e);
}
}
/** {@inheritDoc} */
@MethodLog
@Override
public RecordingData getRecordingData() {
if (storageManager.getRecordingState() == RecordingState.ON
|| storageManager.getRecordingState() == RecordingState.SCHEDULED) {
RecordingData recordingData = new RecordingData();
RecordingProperties recordingProperties = storageManager.getRecordingProperties();
if (null != recordingProperties) {
recordingData.setRecordStartDate(recordingProperties.getRecordStartDate());
recordingData.setRecordEndDate(recordingProperties.getRecordEndDate());
}
recordingData.setRecordingStorage(storageManager.getRecordingStorage());
recordingData.setRecordingWritingStatus(storageManager.getRecordingStatus());
return recordingData;
} else {
return null;
}
}
/**
* {@inheritDoc}
*
* @throws StorageException
*/
@MethodLog
public void closeStorage(StorageData storageData) throws StorageException {
try {
storageManager.closeStorage(storageData);
} catch (IOException | SerializationException e) {
throw new StorageException(
"Exception occurred trying to close storage" + storageData + ".", e);
}
}
/**
* Creates the new storage on the CMR with information given in {@link StorageData} object.
*
* @param storageData Information about new storage.
* @throws StorageException When storage creation fails.
*/
@MethodLog
public void createStorage(StorageData storageData) throws StorageException {
try {
storageManager.createStorage(storageData);
} catch (Exception e) {
throw new StorageException(
"Exception occurred trying to create storage" + storageData + ".", e);
}
}
/** {@inheritDoc} */
@MethodLog
public void createStorageFromUploadedDir(final IStorageData localStorageData)
throws StorageException {
try {
storageManager.createStorageFromUploadedDir(localStorageData);
} catch (IOException | SerializationException e) {
throw new StorageException(
"Exception occurred trying to create storage from uploaded local storage.", e);
}
}
/** {@inheritDoc} */
@MethodLog
public void cacheStorageData(
StorageData storageData, Collection<? extends DefaultData> data, int hash)
throws StorageException {
if (!storageManager.isStorageExisting(storageData)) {
throw new StorageException(
"The storage "
+ storageData
+ " does not exist on the CMR. Data caching is not possible.");
}
if (!storageManager.isStorageClosed(storageData)) {
throw new StorageException(
"The storage " + storageData + " is still not finalized. Data caching is not possible.");
}
try {
storageManager.cacheStorageData(storageData, data, hash);
} catch (IOException | SerializationException e) {
throw new StorageException("Exception occurred trying to cache data fpr storage.", e);
}
}
/** {@inheritDoc} */
@MethodLog
public StorageData copyBufferToStorage(
StorageData storageData,
List<Long> platformIdents,
Collection<AbstractDataProcessor> dataProcessors,
boolean autoFinalize)
throws StorageException {
try {
storageManager.copyBufferToStorage(storageData, platformIdents, dataProcessors, autoFinalize);
return storageData;
} catch (IOException | SerializationException e) {
throw new StorageException("Copy Buffer to Storage action encountered an error.", e);
}
}
@Override
public StorageData copyDataToStorage(
StorageData storageData,
Collection<Long> elementIds,
long platformIdent,
Collection<AbstractDataProcessor> dataProcessors,
boolean autoFinalize)
throws StorageException {
try {
storageManager.copyDataToStorage(
storageData, elementIds, platformIdent, dataProcessors, autoFinalize);
return storageData;
} catch (IOException | SerializationException e) {
throw new StorageException("Copy Data to Storage action encountered an error.", e);
}
}
/** {@inheritDoc} */
@MethodLog
public StorageData startOrScheduleRecording(
StorageData storageData, RecordingProperties recordingProperties) throws StorageException {
if ((storageManager.getRecordingState() == RecordingState.ON
|| storageManager.getRecordingState() == RecordingState.SCHEDULED)
&& !storageData.equals(storageManager.getRecordingStorage())) {
throw new StorageException(
"Recording is already active/scheduled with different storage. Only one storage at time can be chosen as recording destination.");
} else if (storageManager.getRecordingState() == RecordingState.ON
|| storageManager.getRecordingState() == RecordingState.SCHEDULED) {
throw new StorageException("Recording is already active/scheduled with selected storage.");
} else {
try {
storageManager.startOrScheduleRecording(storageData, recordingProperties);
return storageManager.getRecordingStorage();
} catch (IOException | SerializationException e) {
throw new StorageException(
"Exception occurred trying to start recording on storage " + storageData + ".", e);
}
}
}
/** {@inheritDoc} */
@MethodLog
public List<StorageData> getOpenedStorages() {
return storageManager.getOpenedStorages();
}
/** {@inheritDoc} */
@MethodLog
public List<StorageData> getExistingStorages() {
return storageManager.getExistingStorages();
}
/** {@inheritDoc} */
@MethodLog
public long getStorageQueuedWriteTaskCount(StorageData storageData) {
return storageManager.getStorageQueuedWriteTaskCount(storageData);
}
/** {@inheritDoc} */
@MethodLog
public List<StorageData> getReadableStorages() {
return storageManager.getReadableStorages();
}
/** {@inheritDoc} */
@MethodLog
public RecordingState getRecordingState() {
return storageManager.getRecordingState();
}
/** {@inheritDoc} */
@MethodLog
public boolean isStorageOpen(StorageData storageData) {
return storageManager.isStorageOpen(storageData);
}