/**
* Keep track of invalid cache paths to later inform cluster to invalidate the given paths from
* caches.
*
* @param path ModelObject storage path
*/
private void addInvalidCachePath(final String path) {
if (logger.isDebugEnabled()) logger.debug("Adding invalid cache path: " + path);
RequestContext rc = ThreadLocalRequestContext.getRequestContext();
if (!(rc instanceof ClusterAwareRequestContext)) {
throw new IllegalStateException(
"Incorrect Share cluster configuration detected - ClusterAwareRequestContextFactory is required.");
}
((ClusterAwareRequestContext) rc).addInvalidCachePath(path);
}
/**
* Constructs a new <code>PageView</code> object using and sets it's URL to the current view name
* providing that a <code>Page</code> object is stored on the current <code>RequestContext</code>
* object.
*
* @param viewName The name of the view to build.
*/
@Override
protected AbstractUrlBasedView buildView(String viewName) {
PageView view = null;
Page page = ThreadLocalRequestContext.getRequestContext().getPage();
if (page != null) {
view =
new AikauPageView(
getWebframeworkConfigElement(),
getModelObjectService(),
getWebFrameworkResourceService(),
getWebFrameworkRenderService(),
getTemplatesContainer());
view.setUrl(viewName);
view.setPage(page);
view.setUriTokens(ThreadLocalRequestContext.getRequestContext().getUriTokens());
view.setUrlHelperFactory(getUrlHelperFactory());
}
return view;
}
@Override
public void execute(WebScriptRequest req, WebScriptResponse res) throws IOException {
Writer writer = null;
try {
writer = res.getWriter();
// Get the section placed in the request context by ApplicationDataInterceptor
RequestContext requestContext = ThreadLocalRequestContext.getRequestContext();
Section section = (Section) requestContext.getValue("section");
WebSite webSite = (WebSite) requestContext.getValue("webSite");
// Get the collection property from the page definition
String collectionName = requestContext.getPage().getProperty("collection");
if (collectionName == null)
throw new WebScriptException("collectionName property must be supplied");
// Fetch the named collection
AssetCollection collection =
(AssetCollection) collectionFactory.getCollection(section.getId(), collectionName);
// Use ROME library to output the colleciton as a syndication feed
SyndFeed feed = new SyndFeedImpl();
feed.setFeedType(FEED_TYPE);
feed.setTitle(section.getTitle());
feed.setLink(urlUtils.getWebsiteDomain(webSite) + urlUtils.getUrl(section));
feed.setDescription(section.getDescription());
List<SyndEntry> entries = new ArrayList<SyndEntry>();
for (Asset asset : collection.getAssets()) {
SyndEntry entry = new SyndEntryImpl();
entry.setTitle(asset.getTitle());
entry.setLink(urlUtils.getWebsiteDomain(webSite) + urlUtils.getUrl(asset));
entry.setUri(urlUtils.getWebsiteDomain(webSite) + urlUtils.getShortUrl(asset));
entry.setPublishedDate((Date) asset.getProperties().get(Asset.PROPERTY_PUBLISHED_TIME));
SyndContent description = new SyndContentImpl();
description.setType("text/html");
description.setValue(asset.getDescription());
entry.setDescription(description);
entries.add(entry);
}
feed.setEntries(entries);
SyndFeedOutput output = new SyndFeedOutput();
output.output(feed, writer);
writer.flush();
} catch (IOException e) {
log.error("Unable to output rss", e);
} catch (FeedException e) {
log.error("Unable to output rss", e);
}
}
@Override
protected Page lookupPage(String pageId) {
if (ThreadLocalRequestContext.getRequestContext().getUser() == null) {
HttpServletRequest req = AikauAuthenticationFilter.getCurrentServletRequest();
if (req != null) {
try {
// init the request user context if the thread local is found containing the
// servlet request information - this ensures an authenticated Connector is
// used when makes a remote call to resolve the Page from the view name
RequestContextUtil.initRequestContext(getApplicationContext(), req);
} catch (RequestContextException e) {
throw new PlatformRuntimeException(
"Failed to init Request Context: " + e.getMessage(), e);
}
}
}
// see if a page has been set-up already - @see UserDashboardInterceptor
Page page = ThreadLocalRequestContext.getRequestContext().getPage();
if (page != null) {
return page;
}
return super.lookupPage(pageId);
}
/**
* Thread-safe get of the singleton value. Can be optionally stored per tenant based on user Id.
*
* @param tenant True to get/store per tenant, false for a single value for all repo instances.
* @return singleton value, optionally per tenant.
*/
protected final T getSingletonValue(final boolean tenant) {
T result;
final String userId = ThreadLocalRequestContext.getRequestContext().getUserId();
final String storeId = tenant ? getTenantUserStore(userId) : "";
// NOTE: currently there is a single RRW lock for all values -
// in a heavily multi-tenant scenario (especially ones with new tenants
// being created often) the first access of a new tenant dictionary would
// potentially slow other tenant users access to their dictionary.
// In this situation a lock per tenant would be preferable.
this.lock.readLock().lock();
try {
result = storeValues.get(storeId);
if (result == null) {
this.lock.readLock().unlock();
this.lock.writeLock().lock();
try {
// check again, as more than one thread could have been waiting on the Write lock
result = storeValues.get(storeId);
if (result == null) {
// call the retrieve implementation - probably going to do a remote call or similar
result = retrieveValue(userId, storeId);
// store result against the current store i.e. tenant
storeValues.put(storeId, result);
}
} catch (ConnectorServiceException cerr) {
throw new AlfrescoRuntimeException(
"Unable to retrieve "
+ getValueName()
+ " configuration from Alfresco: "
+ cerr.getMessage());
} catch (Exception err) {
throw new AlfrescoRuntimeException(
"Failed during processing of "
+ getValueName()
+ " configuration from Alfresco: "
+ err.getMessage());
} finally {
this.lock.readLock().lock();
this.lock.writeLock().unlock();
}
}
} finally {
this.lock.readLock().unlock();
}
return result;
}
@Override
public String toString() {
try {
String out = "";
final RequestContext rc = ThreadLocalRequestContext.getRequestContext();
final String userId = rc.getUserId();
if (userId != null && !AuthenticationUtil.isGuest(userId)) {
int idx = userId.indexOf('@');
if (idx != -1) {
out = "Mimetypes for user domain: " + userId.substring(idx) + "\r\n";
}
}
return out + getMimetypes().toString();
} catch (Throwable e) {
return super.toString();
}
}
@Override
protected Map<String, Mimetype> retrieveValue(final String userId, final String storeId)
throws ConnectorServiceException {
Map<String, Mimetype> mimetypes;
// initiate a call to retrieve the dictionary from the repository
final RequestContext rc = ThreadLocalRequestContext.getRequestContext();
final Connector conn =
rc.getServiceRegistry()
.getConnectorService()
.getConnector("alfresco", userId, ServletUtil.getSession());
final Response response = conn.call("/api/mimetypes/descriptions");
if (response.getStatus().getCode() == Status.STATUS_OK) {
logger.info("Successfully retrieved mimetypes information from Alfresco.");
mimetypes = new HashMap<String, Mimetype>(128);
try {
// Extract mimetype information
final JSONObject json = new JSONObject(response.getResponse());
final JSONObject data = json.getJSONObject("data");
Iterator<String> types = data.keys();
while (types.hasNext()) {
// The type is the key
String mimetype = types.next();
// The details come from the value
Mimetype details = new Mimetype(mimetype, data.getJSONObject(mimetype));
mimetypes.put(mimetype, details);
}
} catch (JSONException e) {
throw new AlfrescoRuntimeException(e.getMessage(), e);
}
} else {
throw new AlfrescoRuntimeException(
"Unable to retrieve mimetypes information from Alfresco: "
+ response.getStatus().getCode());
}
return mimetypes;
}
/**
* Retrieves content from the given remote store and streams back to the response
*
* @param request http servlet request
* @param response http servlet response
* @param path the path to be included
* @param endpointId the endpoint to utilize (optional)
* @param storeId the store to utilize (optional)
* @param webappId the webapp to utilize (optional)
* @return whether the resource was served back successfully
*/
public boolean retrieveRemoteResource(
HttpServletRequest request,
HttpServletResponse response,
String path,
String endpointId,
String storeId,
String webappId)
throws ServletException, IOException {
boolean resolved = false;
// get the request context
RequestContext context = ThreadLocalRequestContext.getRequestContext();
// default treatment of these fellows
if (endpointId == null) {
endpointId = this.remoteConfig.getDefaultEndpointId();
}
if (storeId != null) {
// use the currently bound request context store id
storeId =
context
.getServiceRegistry()
.getObjectPersistenceService()
.getPersistenceContext()
.getStoreId();
}
if (webappId == null) {
// use the currently bound request context web app id
webappId =
context
.getServiceRegistry()
.getObjectPersistenceService()
.getPersistenceContext()
.getWebappId();
}
// check whether the resource exists on the remote store
// TODO: this is expensive... is this the cost of preview-able virtualized remote retrieval?
// TODO: ideally, we could hold a cache and have the authoring server notify test servers of
// changes, but that will require more investigation
boolean exists =
checkRemoteResourceExists(context, request, response, path, endpointId, storeId, webappId);
if (exists) {
// build a URL to the endpoint proxy servlet
StringBuilder fb = new StringBuilder(128);
fb.append(request.getServletPath());
fb.append("/endpoint/");
fb.append(endpointId);
fb.append("/avmstore/get/s/");
fb.append(storeId);
fb.append("/w/");
fb.append(webappId);
if (!path.startsWith("/")) {
fb.append("/");
}
fb.append(path);
String newUri = fb.toString();
if (logger.isDebugEnabled()) logger.debug("Formed virtual retrieval path: " + newUri);
// make sure the request uri is properly established so that we can
// flow through the proxy servlet
if (request instanceof WrappedHttpServletRequest) {
((WrappedHttpServletRequest) request).setRequestURI(request.getContextPath() + newUri);
}
// dispatch to the endpoint proxy servlet
RequestDispatcher dispatcher = getServletContext().getRequestDispatcher(newUri);
dispatcher.include(request, response);
resolved = true;
}
return resolved;
}