/**
* 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;
}
/**
* Adds to an specific given bundle a given asset. <br>
* If the given bundle does not exist a new onw will be created with that name
*
* @param request HttpRequest
* @param response HttpResponse
*/
public void addToBundle(HttpServletRequest request, HttpServletResponse response)
throws IOException {
PublisherAPI publisherAPI = PublisherAPI.getInstance();
String _assetId = request.getParameter("assetIdentifier");
String _contentFilterDate = request.getParameter("remoteFilterDate");
String bundleName = request.getParameter("bundleName");
String bundleId = request.getParameter("bundleSelect");
try {
Bundle bundle;
if (bundleId == null || bundleName.equals(bundleId)) {
// if the user has a unsent bundle with that name just add to it
bundle = null;
for (Bundle b :
APILocator.getBundleAPI()
.getUnsendBundlesByName(getUser().getUserId(), bundleName, 1000, 0)) {
if (b.getName().equalsIgnoreCase(bundleName)) {
bundle = b;
}
}
if (bundle == null) {
bundle = new Bundle(bundleName, null, null, getUser().getUserId());
APILocator.getBundleAPI().saveBundle(bundle);
}
} else {
bundle = APILocator.getBundleAPI().getBundleById(bundleId);
}
// Put the selected bundle in session in order to have last one selected
request.getSession().setAttribute(WebKeys.SELECTED_BUNDLE, bundle);
List<String> ids;
if (_assetId.startsWith("query_")) { // Support for lucene queries
String luceneQuery = _assetId.replace("query_", "");
List<String> queries = new ArrayList<String>();
queries.add(luceneQuery);
ids = PublisherUtil.getContentIds(queries);
} else {
String[] _assetsIds =
_assetId.split(","); // Support for multiple ids in the assetIdentifier parameter
List<String> assetsIds = Arrays.asList(_assetsIds);
ids = getIdsToPush(assetsIds, _contentFilterDate, new SimpleDateFormat("yyyy-MM-dd-H-m"));
}
Map<String, Object> responseMap =
publisherAPI.saveBundleAssets(ids, bundle.getId(), getUser());
// If we have errors lets return them in order to feedback the user
if (responseMap != null && !responseMap.isEmpty()) {
// Error messages
JSONArray jsonErrors = new JSONArray((ArrayList) responseMap.get("errorMessages"));
// Prepare the Json response
JSONObject jsonResponse = new JSONObject();
jsonResponse.put("errorMessages", jsonErrors.toArray());
jsonResponse.put("errors", responseMap.get("errors"));
jsonResponse.put("total", responseMap.get("total"));
// And send it back to the user
response.getWriter().println(jsonResponse.toString());
}
} catch (Exception e) {
Logger.error(RemotePublishAjaxAction.class, e.getMessage(), e);
response.sendError(
HttpStatus.SC_INTERNAL_SERVER_ERROR, "Error Adding content to Bundle: " + e.getMessage());
}
}
@Override
public void service(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
Map<String, String> map = getURIParams();
String cmd = map.get("cmd");
Method dispatchMethod = null;
User user = getUser();
try {
// Check permissions if the user has access to the CMS Maintenance Portlet
if (user == null) {
String userName =
map.get("u") != null ? map.get("u") : map.get("user") != null ? map.get("user") : null;
String password =
map.get("p") != null
? map.get("p")
: map.get("passwd") != null ? map.get("passwd") : null;
LoginFactory.doLogin(userName, password, false, request, response);
user = (User) request.getSession().getAttribute(WebKeys.CMS_USER);
// Set the logged user in order to make it available from this action using the getUser()
// method
if (user != null) {
setUser(user);
}
if (user == null) {
setUser(request);
user = getUser();
}
if (user == null) {
response.sendError(401);
return;
}
}
} catch (Exception e) {
Logger.error(this.getClass(), e.getMessage());
response.sendError(401);
return;
}
if (null != cmd) {
try {
dispatchMethod =
this.getClass()
.getMethod(cmd, new Class[] {HttpServletRequest.class, HttpServletResponse.class});
} catch (Exception e) {
try {
dispatchMethod =
this.getClass()
.getMethod(
"action", new Class[] {HttpServletRequest.class, HttpServletResponse.class});
} catch (Exception e1) {
Logger.error(this.getClass(), "Trying to get method:" + cmd);
Logger.error(this.getClass(), e1.getMessage(), e1.getCause());
throw new DotRuntimeException(e1.getMessage());
}
}
try {
dispatchMethod.invoke(this, new Object[] {request, response});
} catch (Exception e) {
Logger.error(this.getClass(), "Trying to invoke method:" + cmd);
Logger.error(this.getClass(), e.getMessage(), e.getCause());
throw new DotRuntimeException(e.getMessage());
}
}
}
/**
* 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);
}
}
}
}
/**
* Send to the publisher queue a list of assets for a given Operation (Publish/Unpublish) and
* {@link Environment Environment}
*
* @param request HttpRequest
* @param response HttpResponse
* @throws WorkflowActionFailureException If fails adding the content for Publish
* @see com.dotcms.publisher.business.PublisherQueueJob
* @see Environment
*/
public void publish(HttpServletRequest request, HttpServletResponse response)
throws IOException, WorkflowActionFailureException {
try {
PublisherAPI publisherAPI = PublisherAPI.getInstance();
// Read the form values
String _assetId = request.getParameter("assetIdentifier");
String _contentPushPublishDate = request.getParameter("remotePublishDate");
String _contentPushPublishTime = request.getParameter("remotePublishTime");
String _contentPushExpireDate = request.getParameter("remotePublishExpireDate");
String _contentPushExpireTime = request.getParameter("remotePublishExpireTime");
String _contentFilterDate = request.getParameter("remoteFilterDate");
String _iWantTo = request.getParameter("iWantTo");
String whoToSendTmp = request.getParameter("whoToSend");
String forcePushStr = request.getParameter("forcePush");
boolean forcePush = (forcePushStr != null && forcePushStr.equals("true"));
List<String> whereToSend = Arrays.asList(whoToSendTmp.split(","));
List<Environment> envsToSendTo = new ArrayList<Environment>();
// Lists of Environments to push to
for (String envId : whereToSend) {
Environment e = APILocator.getEnvironmentAPI().findEnvironmentById(envId);
if (e != null) {
envsToSendTo.add(e);
}
}
// Put the selected environments in session in order to have the list of the last selected
// environments
request.getSession().setAttribute(WebKeys.SELECTED_ENVIRONMENTS, envsToSendTo);
SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd-H-m");
Date publishDate = dateFormat.parse(_contentPushPublishDate + "-" + _contentPushPublishTime);
List<String> ids;
if (_assetId.startsWith("query_")) { // Support for lucene queries
String luceneQuery = _assetId.replace("query_", "");
List<String> queries = new ArrayList<String>();
queries.add(luceneQuery);
ids = PublisherUtil.getContentIds(queries);
} else {
String[] _assetsIds =
_assetId.split(","); // Support for multiple ids in the assetIdentifier parameter
List<String> assetsIds = Arrays.asList(_assetsIds);
ids = getIdsToPush(assetsIds, _contentFilterDate, dateFormat);
}
// Response map with the status of the addContents operation (error messages and counts )
Map<String, Object> responseMap = null;
if (_iWantTo.equals(RemotePublishAjaxAction.DIALOG_ACTION_PUBLISH)
|| _iWantTo.equals(RemotePublishAjaxAction.DIALOG_ACTION_PUBLISH_AND_EXPIRE)) {
Bundle bundle = new Bundle(null, publishDate, null, getUser().getUserId(), forcePush);
APILocator.getBundleAPI().saveBundle(bundle, envsToSendTo);
responseMap =
publisherAPI.addContentsToPublish(ids, bundle.getId(), publishDate, getUser());
}
if (_iWantTo.equals(RemotePublishAjaxAction.DIALOG_ACTION_EXPIRE)
|| _iWantTo.equals(RemotePublishAjaxAction.DIALOG_ACTION_PUBLISH_AND_EXPIRE)) {
if ((!"".equals(_contentPushExpireDate.trim())
&& !"".equals(_contentPushExpireTime.trim()))) {
Date expireDate = dateFormat.parse(_contentPushExpireDate + "-" + _contentPushExpireTime);
Bundle bundle =
new Bundle(null, publishDate, expireDate, getUser().getUserId(), forcePush);
APILocator.getBundleAPI().saveBundle(bundle, envsToSendTo);
responseMap =
publisherAPI.addContentsToUnpublish(ids, bundle.getId(), expireDate, getUser());
}
}
// If we have errors lets return them in order to feedback the user
if (responseMap != null && !responseMap.isEmpty()) {
// Error messages
JSONArray jsonErrors = new JSONArray((ArrayList) responseMap.get("errorMessages"));
// Prepare the Json response
JSONObject jsonResponse = new JSONObject();
jsonResponse.put("errorMessages", jsonErrors.toArray());
jsonResponse.put("errors", responseMap.get("errors"));
jsonResponse.put("total", responseMap.get("total"));
jsonResponse.put("bundleId", responseMap.get("bundleId"));
// And send it back to the user
response.getWriter().println(jsonResponse.toString());
}
} catch (Exception e) {
Logger.error(RemotePublishAjaxAction.class, e.getMessage(), e);
response.sendError(
HttpStatus.SC_INTERNAL_SERVER_ERROR, "Error Publishing Bundle: " + e.getMessage());
}
}