/**
* Downloads a Bundle file for a given bundle id.
*
* @param request HttpRequest
* @param response HttpResponse
* @throws IOException If fails sending back to the user response information
*/
public void downloadBundle(HttpServletRequest request, HttpServletResponse response)
throws IOException {
try {
if (!APILocator.getLayoutAPI()
.doesUserHaveAccessToPortlet("EXT_CONTENT_PUBLISHING_TOOL", getUser())) {
response.sendError(401);
return;
}
} catch (DotDataException e1) {
Logger.error(RemotePublishAjaxAction.class, e1.getMessage(), e1);
response.sendError(401);
return;
}
Map<String, String> map = getURIParams();
response.setContentType("application/x-tgz");
String bid = map.get("bid");
PublisherConfig config = new PublisherConfig();
config.setId(bid);
File bundleRoot = BundlerUtil.getBundleRoot(config);
ArrayList<File> list = new ArrayList<File>(1);
list.add(bundleRoot);
File bundle =
new File(bundleRoot + File.separator + ".." + File.separator + config.getId() + ".tar.gz");
if (!bundle.exists()) {
response.sendError(500, "No Bundle Found");
return;
}
response.setHeader("Content-Disposition", "attachment; filename=" + config.getId() + ".tar.gz");
BufferedInputStream in = null;
try {
in = new BufferedInputStream(new FileInputStream(bundle));
byte[] buf = new byte[4096];
int len;
while ((len = in.read(buf, 0, buf.length)) != -1) {
response.getOutputStream().write(buf, 0, len);
}
} catch (Exception e) {
Logger.warn(this.getClass(), "Error Downloading Bundle.", e);
} finally {
try {
in.close();
} catch (Exception ex) {
Logger.warn(this.getClass(), "Error Closing Stream.", ex);
}
}
return;
}
/**
* Generates an Unpublish bundle for a given bundle id operation (publish/unpublish)
*
* @param bundleId The Bundle id of the Bundle we want to generate
* @param operation Download for publish or un-publish
* @return The generated requested Bundle file
* @throws DotPublisherException If fails retrieving the Bundle contents
* @throws DotDataException If fails finding the system user
* @throws DotPublishingException If fails initializing the Publisher
* @throws IllegalAccessException If fails creating new Bundlers instances
* @throws InstantiationException If fails creating new Bundlers instances
* @throws DotBundleException If fails generating the Bundle
* @throws IOException If fails compressing the all the Bundle contents into the final Bundle file
*/
@SuppressWarnings("unchecked")
private Map<String, Object> generateBundle(
String bundleId, PushPublisherConfig.Operation operation)
throws DotPublisherException, DotDataException, DotPublishingException,
IllegalAccessException, InstantiationException, DotBundleException, IOException {
PushPublisherConfig pconf = new PushPublisherConfig();
PublisherAPI pubAPI = PublisherAPI.getInstance();
List<PublishQueueElement> tempBundleContents = pubAPI.getQueueElementsByBundleId(bundleId);
List<PublishQueueElement> assetsToPublish =
new ArrayList<PublishQueueElement>(); // all assets but contentlets
for (PublishQueueElement c : tempBundleContents) {
if (!c.getType().equals("contentlet")) {
assetsToPublish.add(c);
}
}
pconf.setDownloading(true);
pconf.setOperation(operation);
// all types of assets in the queue but contentlets are passed here, which are passed through
// lucene queries
pconf.setAssets(assetsToPublish);
// Queries creation
pconf.setLuceneQueries(PublisherUtil.prepareQueries(tempBundleContents));
pconf.setId(bundleId);
pconf.setUser(APILocator.getUserAPI().getSystemUser());
// BUNDLERS
List<Class<IBundler>> bundlers = new ArrayList<Class<IBundler>>();
List<IBundler> confBundlers = new ArrayList<IBundler>();
Publisher publisher = new PushPublisher();
publisher.init(pconf);
// Add the bundles for this publisher
for (Class clazz : publisher.getBundlers()) {
if (!bundlers.contains(clazz)) {
bundlers.add(clazz);
}
}
// Create a new bundle id for this generated bundle
String newBundleId = UUID.randomUUID().toString();
pconf.setId(newBundleId);
File bundleRoot = BundlerUtil.getBundleRoot(pconf);
// Run bundlers
BundlerUtil.writeBundleXML(pconf);
for (Class<IBundler> c : bundlers) {
IBundler bundler = c.newInstance();
confBundlers.add(bundler);
bundler.setConfig(pconf);
BundlerStatus bundlerStatus = new BundlerStatus(bundler.getClass().getName());
// Generate the bundler
bundler.generate(bundleRoot, bundlerStatus);
}
pconf.setBundlers(confBundlers);
// Compressing bundle
ArrayList<File> list = new ArrayList<File>();
list.add(bundleRoot);
File bundle =
new File(bundleRoot + File.separator + ".." + File.separator + pconf.getId() + ".tar.gz");
Map<String, Object> bundleData = new HashMap<String, Object>();
bundleData.put("id", newBundleId);
bundleData.put("file", PushUtils.compressFiles(list, bundle, bundleRoot.getAbsolutePath()));
return bundleData;
}
/**
* Generates and flush an Unpublish bundle for a given bundle id and operation (publish/unpublish)
*
* @param request HttpRequest
* @param response HttpResponse
* @throws IOException If fails sending back to the user response information
*/
public void downloadUnpushedBundle(HttpServletRequest request, HttpServletResponse response)
throws IOException {
try {
if (!APILocator.getLayoutAPI()
.doesUserHaveAccessToPortlet("EXT_CONTENT_PUBLISHING_TOOL", getUser())) {
response.sendError(401);
return;
}
} catch (DotDataException e1) {
Logger.error(RemotePublishAjaxAction.class, e1.getMessage(), e1);
response.sendError(401);
return;
}
// Read the parameters
Map<String, String> map = getURIParams();
String bundleId = map.get("bundleId");
String paramOperation = map.get("operation");
if (bundleId == null || bundleId.isEmpty()) {
Logger.error(this.getClass(), "No Bundle Found with id: " + bundleId);
response.sendError(500, "No Bundle Found with id: " + bundleId);
return;
}
// What we want to do with this bundle
PushPublisherConfig.Operation operation = PushPublisherConfig.Operation.PUBLISH;
if (paramOperation != null && paramOperation.equalsIgnoreCase("unpublish")) {
operation = PushPublisherConfig.Operation.UNPUBLISH;
}
File bundle;
String generatedBundleId;
try {
// Generate the bundle file for this given operation
Map<String, Object> bundleData = generateBundle(bundleId, operation);
bundle = (File) bundleData.get("file");
generatedBundleId = (String) bundleData.get("id");
} catch (Exception e) {
Logger.error(this.getClass(), "Error trying to generate bundle with id: " + bundleId, e);
response.sendError(500, "Error trying to generate bundle with id: " + bundleId);
return;
}
response.setContentType("application/x-tgz");
response.setHeader("Content-Disposition", "attachment; filename=" + bundle.getName());
BufferedInputStream in = null;
try {
in = new BufferedInputStream(new FileInputStream(bundle));
byte[] buf = new byte[4096];
int len;
while ((len = in.read(buf, 0, buf.length)) != -1) {
response.getOutputStream().write(buf, 0, len);
}
} catch (Exception e) {
Logger.error(this.getClass(), "Error reading bundle stream for bundle id: " + bundleId, e);
response.sendError(500, "Error reading bundle stream for bundle id: " + bundleId);
} finally {
try {
in.close();
} catch (Exception ex) {
Logger.error(this.getClass(), "Error closing Stream for bundle: " + bundleId, ex);
}
// Clean the just created bundle because on each download we will generate a new bundle file
// with a new id in order to avoid conflicts with ids
File bundleRoot = BundlerUtil.getBundleRoot(generatedBundleId);
File compressedBundle =
new File(ConfigUtils.getBundlePath() + File.separator + generatedBundleId + ".tar.gz");
if (compressedBundle.exists()) {
compressedBundle.delete();
if (bundleRoot.exists()) {
com.liferay.util.FileUtil.deltree(bundleRoot);
}
}
}
}
/**
* Allow the user to send or try to send again failed and successfully sent bundles, in order to
* do that<br>
* we send the bundle again to que publisher queue job which will try to remote publish again the
* bundle.
*
* @param request HttpRequest
* @param response HttpResponse
* @throws IOException If fails sending back to the user a proper response
* @throws DotPublisherException If fails retrieving the Bundle related information like elements
* on it and statuses
* @throws LanguageException If fails using i18 messages
*/
public void retry(HttpServletRequest request, HttpServletResponse response)
throws IOException, DotPublisherException, LanguageException {
PublisherAPI publisherAPI = PublisherAPI.getInstance();
PublishAuditAPI publishAuditAPI = PublishAuditAPI.getInstance();
// Read the parameters
String bundlesIds = request.getParameter("bundlesIds");
String[] ids = bundlesIds.split(",");
StringBuilder responseMessage = new StringBuilder();
for (String bundleId : ids) {
if (bundleId.trim().isEmpty()) {
continue;
}
PublisherConfig basicConfig = new PublisherConfig();
basicConfig.setId(bundleId);
File bundleRoot = BundlerUtil.getBundleRoot(basicConfig);
// Get the audit records related to this bundle
PublishAuditStatus status = PublishAuditAPI.getInstance().getPublishAuditStatus(bundleId);
String pojo_string = status.getStatusPojo().getSerialized();
PublishAuditHistory auditHistory = PublishAuditHistory.getObjectFromString(pojo_string);
// First we need to verify is this bundle is already in the queue job
List<PublishQueueElement> foundBundles = publisherAPI.getQueueElementsByBundleId(bundleId);
if (foundBundles != null && !foundBundles.isEmpty()) {
appendMessage(responseMessage, "publisher_retry.error.already.in.queue", bundleId, true);
continue;
}
// We will be able to retry failed and successfully bundles
if (!(status.getStatus().equals(Status.FAILED_TO_PUBLISH)
|| status.getStatus().equals(Status.SUCCESS))) {
appendMessage(responseMessage, "publisher_retry.error.only.failed.publish", bundleId, true);
continue;
}
/*
Verify if the bundle exist and was created correctly..., meaning, if there is not a .tar.gz file is because
something happened on the creation of the bundle.
*/
File bundleFile =
new File(
bundleRoot
+ File.separator
+ ".."
+ File.separator
+ basicConfig.getId()
+ ".tar.gz");
if (!bundleFile.exists()) {
Logger.error(this.getClass(), "No Bundle with id: " + bundleId + " found.");
appendMessage(responseMessage, "publisher_retry.error.not.found", bundleId, true);
continue;
}
if (!BundlerUtil.bundleExists(basicConfig)) {
Logger.error(
this.getClass(), "No Bundle Descriptor for bundle id: " + bundleId + " found.");
appendMessage(
responseMessage, "publisher_retry.error.not.descriptor.found", bundleId, true);
continue;
}
try {
// Read the bundle to see what kind of configuration we need to apply
String bundlePath = ConfigUtils.getBundlePath() + File.separator + basicConfig.getId();
File xml = new File(bundlePath + File.separator + "bundle.xml");
PushPublisherConfig config = (PushPublisherConfig) BundlerUtil.xmlToObject(xml);
// We can not retry Received Bundles, just bundles that we are trying to send
Boolean sending = sendingBundle(request, config, bundleId);
if (!sending) {
appendMessage(
responseMessage, "publisher_retry.error.cannot.retry.received", bundleId, true);
continue;
}
if (status.getStatus().equals(Status.SUCCESS)) {
// Get the bundle
Bundle bundle = APILocator.getBundleAPI().getBundleById(bundleId);
if (bundle == null) {
Logger.error(this.getClass(), "No Bundle with id: " + bundleId + " found.");
appendMessage(responseMessage, "publisher_retry.error.not.found", bundleId, true);
continue;
}
bundle.setForcePush(true);
APILocator.getBundleAPI().updateBundle(bundle);
}
// Clean the number of tries, we want to try it again
auditHistory.setNumTries(0);
publishAuditAPI.updatePublishAuditStatus(
config.getId(), status.getStatus(), auditHistory, true);
// Get the identifiers on this bundle
HashSet<String> identifiers = new HashSet<String>();
List<PublishQueueElement> assets = config.getAssets();
if (config.getLuceneQueries() != null && !config.getLuceneQueries().isEmpty()) {
identifiers.addAll(PublisherUtil.getContentIds(config.getLuceneQueries()));
}
if (assets != null && !assets.isEmpty()) {
for (PublishQueueElement asset : assets) {
identifiers.add(asset.getAsset());
}
}
// Now depending of the operation lets add it to the queue job
if (config.getOperation().equals(PushPublisherConfig.Operation.PUBLISH)) {
publisherAPI.addContentsToPublish(
new ArrayList<String>(identifiers), bundleId, new Date(), getUser());
} else {
publisherAPI.addContentsToUnpublish(
new ArrayList<String>(identifiers), bundleId, new Date(), getUser());
}
// Success...
appendMessage(responseMessage, "publisher_retry.success", bundleId, false);
} catch (Exception e) {
Logger.error(
this.getClass(),
"Error trying to add bundle id: " + bundleId + " to the Publishing Queue.",
e);
appendMessage(responseMessage, "publisher_retry.error.adding.to.queue", bundleId, true);
}
}
response.getWriter().println(responseMessage.toString());
}