/*******************************************************************************
* Copyright (c) 2010-2014 SAP AG and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* SAP AG - initial API and implementation
*******************************************************************************/
package org.eclipse.skalli.core.rest.admin;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.text.MessageFormat;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.zip.ZipEntry;
import java.util.zip.ZipInputStream;
import java.util.zip.ZipOutputStream;
import org.apache.commons.io.IOUtils;
import org.apache.commons.lang.StringUtils;
import org.apache.commons.lang.math.NumberUtils;
import org.eclipse.skalli.commons.CollectionUtils;
import org.eclipse.skalli.commons.FormatUtils;
import org.eclipse.skalli.commons.ThreadPool;
import org.eclipse.skalli.core.storage.FileStorageComponent;
import org.eclipse.skalli.services.BundleProperties;
import org.eclipse.skalli.services.ServiceFilter;
import org.eclipse.skalli.services.Services;
import org.eclipse.skalli.services.extension.rest.ResourceBase;
import org.eclipse.skalli.services.permit.Permits;
import org.eclipse.skalli.services.persistence.PersistenceService;
import org.eclipse.skalli.services.persistence.StorageConsumer;
import org.eclipse.skalli.services.persistence.StorageService;
import org.eclipse.skalli.services.search.SearchQuery;
import org.restlet.data.Disposition;
import org.restlet.data.MediaType;
import org.restlet.data.Status;
import org.restlet.representation.OutputRepresentation;
import org.restlet.representation.Representation;
import org.restlet.resource.Get;
import org.restlet.resource.Put;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class ProjectBackupResource extends ResourceBase {
private static final Logger LOG = LoggerFactory.getLogger(ProjectBackupResource.class);
private static final String FILE_NAME = "backup.zip"; //$NON-NLS-1$
private static final String EXCLUDE_PARAM = "exclude"; //$NON-NLS-1$
private static final String INCLUDE_PARAM = "include"; //$NON-NLS-1$
private static final String ACTION_PARAM = "action"; //$NON-NLS-1$
private static final String ACTION_OVERWRITE = "overwrite"; //$NON-NLS-1$
// error codes for logging and error responses
private static final String ID_PREFIX = "rest:api/admin/backup:"; //$NON-NLS-1$
private static final String ERROR_ID_IO_ERROR = ID_PREFIX + "00"; //$NON-NLS-1$
private static final String ERROR_ID_NO_STORAGE_SERVICE = ID_PREFIX + "10"; //$NON-NLS-1$
private static final String ERROR_ID_FAILED_TO_RETRIEVE_KEYS = ID_PREFIX + "20"; //$NON-NLS-1$
private static final String ERROR_ID_FAILED_TO_STORE = ID_PREFIX + "30"; //$NON-NLS-1$
private static final String ERROR_ID_OVERWRITE_EXISTING_DATA = ID_PREFIX + "40"; //$NON-NLS-1$
@SuppressWarnings("nls")
private static final Set<String> CATEGORIES = CollectionUtils.asSet("customization", "Project", "Issues",
"Favorites", "User", "Group", "History");
@Get
public Representation backup() {
if (!Permits.isAllowed(getAction(), getPath())) {
return createUnauthorizedRepresentation();
}
StorageService storageService = getStorageService();
if (storageService == null) {
return createServiceUnavailableRepresentation(ERROR_ID_NO_STORAGE_SERVICE, "Storage Service");
}
Set<String> categories = getCategories();
ZipOutputRepresentation zipRepresentation = new ZipOutputRepresentation(storageService, categories);
Disposition disposition = new Disposition(Disposition.TYPE_ATTACHMENT);
disposition.setFilename(FILE_NAME);
zipRepresentation.setDisposition(disposition);
setStatus(Status.SUCCESS_OK);
return zipRepresentation;
}
@Put
public Representation restore(Representation entity) {
if (!Permits.isAllowed(getAction(), getPath())) {
return createUnauthorizedRepresentation();
}
StorageService storageService = getStorageService();
if (storageService == null) {
return createServiceUnavailableRepresentation(ERROR_ID_NO_STORAGE_SERVICE, "Storage Service");
}
String action = getQueryAttribute(ACTION_PARAM);
Set<String> categories = getCategories();
Set<String> accepted = new HashSet<String>();
Set<String> rejected = new HashSet<String>();
for (String category: CATEGORIES) {
if (categories.contains(category)) {
try {
if (ACTION_OVERWRITE.equals(action) || storageService.keys(category).isEmpty()) {
accepted.add(category);
} else {
rejected.add(category);
}
} catch (IOException e) {
LOG.error(MessageFormat.format("Failed to retrieve keys for category {0} ({1})",
category, ERROR_ID_FAILED_TO_RETRIEVE_KEYS), e);
return createErrorRepresentation(Status.SERVER_ERROR_INTERNAL, ERROR_ID_FAILED_TO_RETRIEVE_KEYS ,
"Failed to store the attached backup resource");
}
}
}
if (rejected.size() > 0) {
return createErrorRepresentation(
Status.CLIENT_ERROR_PRECONDITION_FAILED,
ERROR_ID_OVERWRITE_EXISTING_DATA,
MessageFormat.format(
"Restore might overwrite existing data in the folling categories:\n{0}\n" +
"Either exclude these categories from the restore with a \"exclude=<comma-separated-list>\" " +
"parameter or enforce the restore with \"action=overwrite\".",
CollectionUtils.toString(rejected, '\n')));
}
if (accepted.isEmpty()) {
setStatus(Status.SUCCESS_NO_CONTENT);
return null;
}
boolean withHistory = accepted.contains("History"); //$NON-NLS-1$
int countItems = 0;
int countHistoryItems = 0;
ZipInputStream zipStream = null;
try {
zipStream = new ZipInputStream(entity.getStream());
ZipEntry entry = zipStream.getNextEntry();
while (entry != null) {
try {
if (!entry.isDirectory()) {
String entryName = entry.getName().replace('\\', '/');
String[] parts = StringUtils.split(entryName, '/');
if (parts.length != 2) {
LOG.info(MessageFormat.format("Restore: {0} is not recognized as entity key", entryName));
continue;
}
String category = parts[0];
String name = parts[1];
if (name.endsWith(".xml")) { //$NON-NLS-1$
name = name.substring(0, name.length() - 4);
};
String[] nameParts = StringUtils.split(name, '_');
String key = nameParts[0];
long timestamp = NumberUtils.toLong(nameParts.length == 2 ? nameParts[1] : null, -1L);
// ensure that the category of the entry, i.e. the directory name,
// is in the set of accepted categories
if (accepted.contains(category)) {
if (timestamp < 0) {
try {
storageService.write(category, key, zipStream);
++countItems;
} catch (IOException e) {
LOG.error(MessageFormat.format(
"Failed to store entity with key {0} and category {1} ({2})",
key, category, ERROR_ID_FAILED_TO_STORE), e);
return createErrorRepresentation(Status.SERVER_ERROR_INTERNAL, ERROR_ID_FAILED_TO_STORE,
"Failed to store the attached backup");
}
} else if (withHistory) {
try {
storageService.writeToArchive(category, key, timestamp, zipStream);
++countHistoryItems;
} catch (IOException e) {
LOG.error(MessageFormat.format(
"Failed to store history entry for timestamp {0} with key {1} and category {2} ({3})",
FormatUtils.formatUTCWithMillis(timestamp), key, category,
ERROR_ID_FAILED_TO_STORE), e);
return createErrorRepresentation(Status.SERVER_ERROR_INTERNAL,
ERROR_ID_FAILED_TO_STORE,
"Failed to store the attached backup");
}
}
} else {
LOG.info(MessageFormat.format("Restore: Excluded {0} (category ''{1}'' not accepted)",
key, category));
}
}
} finally {
zipStream.closeEntry();
entry = zipStream.getNextEntry();
}
}
} catch (IOException e) {
return createIOErrorRepresentation(ERROR_ID_IO_ERROR, e);
} finally {
IOUtils.closeQuietly(zipStream);
}
if (LOG.isInfoEnabled()) {
LOG.info(MessageFormat.format("Restored {0} items and {1} history items", countItems, countHistoryItems));
}
// ensure that the persistence service attached to the storage
// refreshes all caches and reloads all entities --- do that
// in the background, otherwise we might run into timeouts
ThreadPool.submit(new Runnable() {
@Override
public void run() {
PersistenceService persistenceService = Services.getService(PersistenceService.class);
if (persistenceService != null) {
LOG.info("Refreshing all caches");
persistenceService.refreshAll();
}
}
});
setStatus(Status.SUCCESS_NO_CONTENT);
return null;
}
/**
* Start with a result set that contains all entries from CATEGORIES,
* except if there is an include list; in this case start with an empty
* result set. Then first add all categories contained in the include list
* and remove afterwards all entries contained in the exclude list.
*/
private Set<String> getCategories() {
Set<String> categories = new HashSet<String>(CATEGORIES);
Set<String> include = CollectionUtils.asSet(StringUtils.split(getQueryAttribute(INCLUDE_PARAM),
SearchQuery.PARAM_LIST_SEPARATOR));
Set<String> exclude = CollectionUtils.asSet(StringUtils.split(getQueryAttribute(EXCLUDE_PARAM),
SearchQuery.PARAM_LIST_SEPARATOR));
if (!include.isEmpty()) {
categories.removeAll(CATEGORIES);
}
categories.addAll(include);
categories.removeAll(exclude);
return categories;
}
private StorageService getStorageService() {
final String storageServiceClassName = BundleProperties.getProperty(
BundleProperties.PROPERTY_STORAGE_SERVICE, FileStorageComponent.class.getName());
Set<StorageService> storageServices = Services.getServices(StorageService.class, new ServiceFilter<StorageService>() {
@Override
public boolean accept(StorageService instance) {
return instance.getClass().getName().equals(storageServiceClassName);
}
});
return storageServices.size() > 0? storageServices.iterator().next() : null;
}
private static class ZipOutputRepresentation extends OutputRepresentation {
private static final int BUFFER = 2048;
private StorageService storageService;
private Set<String> categories;
private boolean withHistory;
public ZipOutputRepresentation(StorageService storageService, Set<String> categories) {
super(MediaType.APPLICATION_ZIP);
this.storageService = storageService;
this.categories = categories;
this.withHistory = categories.contains("History"); //$NON-NLS-1$
}
@Override
public void write(OutputStream out) throws IOException {
ZipOutputStream zipStream = null;
try {
zipStream = new ZipOutputStream(new BufferedOutputStream(out));
for (String category: CATEGORIES) {
if (categories.contains(category)) {
write(category, zipStream);
}
}
zipStream.flush();
} finally {
IOUtils.closeQuietly(zipStream);
}
}
private void write(String category, ZipOutputStream target) throws IOException {
List<String> keys = storageService.keys(category);
for (String key: keys) {
write(category, key, target);
if (withHistory) {
writeHistory(category, key, target);
}
}
}
private void write(String category, String key, final ZipOutputStream target) throws IOException {
String entryName = MessageFormat.format("{0}/{1}.xml", category, key); //$NON-NLS-1$
write(entryName, storageService.read(category, key), target);
}
private void writeHistory(String category, String key, final ZipOutputStream target) throws IOException {
storageService.readFromArchive(category, key, new StorageConsumer() {
@Override
public void consume(String category, String key, long lastModified, InputStream blob)
throws IOException {
String entryName = MessageFormat.format("{0}/{1}_{2}.xml", //$NON-NLS-1$
category, key, Long.toString(lastModified));
write(entryName, blob, target);
}
});
}
private void write(String entryName, InputStream blob, ZipOutputStream target) throws IOException {
BufferedInputStream source = null;
try {
source = new BufferedInputStream(blob, BUFFER);
ZipEntry entry = new ZipEntry(entryName);
target.putNextEntry(entry);
int count;
byte data[] = new byte[BUFFER];
while ((count = source.read(data, 0, BUFFER)) != -1) {
target.write(data, 0, count);
}
} finally {
IOUtils.closeQuietly(source);
}
}
}
}