/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.jetspeed.capabilities.impl;
import java.util.Collection;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.Properties;
import java.util.Vector;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.jetspeed.capabilities.Capabilities;
import org.apache.jetspeed.capabilities.CapabilitiesException;
import org.apache.jetspeed.capabilities.Capability;
import org.apache.jetspeed.capabilities.CapabilityMap;
import org.apache.jetspeed.capabilities.Client;
import org.apache.jetspeed.capabilities.MediaType;
import org.apache.jetspeed.capabilities.MimeType;
import org.apache.jetspeed.capabilities.UnableToBuildCapabilityMapException;
import org.apache.jetspeed.components.dao.InitablePersistenceBrokerDaoSupport;
import org.apache.ojb.broker.query.Criteria;
import org.apache.ojb.broker.query.QueryByCriteria;
import org.apache.ojb.broker.query.QueryFactory;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.BeanFactoryAware;
/**
* Jetspeed Capabilities
*
* @author <a href="mailto:taylor@apache.org">David Sean Taylor</a>
* @author <a href="mailto:roger.ruttimann@earthlink.net">Roger Ruttimann</a>
* @version $Id: JetspeedCapabilities.java 517124 2007-03-12 08:10:25Z ate $
*/
public class JetspeedCapabilities extends InitablePersistenceBrokerDaoSupport implements Capabilities ,BeanFactoryAware
{
private static final Log log =
LogFactory.getLog(JetspeedCapabilities.class);
public static final String DEFAULT_AGENT = "Mozilla/4.0";
public static final String AGENT_XML = "agentxml/1.0";
// Cache for the capability maps
Hashtable capabilityMapCache = new Hashtable();
private Collection clients = null;
/**
* added support for bean factory to create profile rules
*/
private BeanFactory beanFactory;
/** named bean references */
private String clientBeanName;
private String capabilityBeanName;
private String mimeTypeBeanName;
private String mediaTypeBeanName;
private Class clientClass;
private Class capabilityClass;
private Class mimeTypeClass;
private Class mediaTypeClass;
public JetspeedCapabilities(String repositoryPath, String clientBeanName, String mediaTypeBeanName, String mimeTypeBeanName, String capabilityBeanName)
{
super(repositoryPath);
this.clientBeanName = clientBeanName;
this.capabilityBeanName = capabilityBeanName;
this.mimeTypeBeanName = mimeTypeBeanName;
this.mediaTypeBeanName = mediaTypeBeanName;
}
/**
* Create a JetspeedProfiler with properties. Expected properties are:
*
* defaultRule = the default profiling rule
* anonymousUser = the name of the anonymous user
* persistenceStoreName = The name of the persistence persistenceStore component to connect to
* services.profiler.locator.impl = the pluggable Profile Locator impl
* services.profiler.principalRule.impl = the pluggable Principal Rule impl
* services.profiler.profilingRule.impl = the pluggable Profiling Rule impl
*
* @param persistenceStore The persistence persistenceStore
* @param properties Properties for this component described above
* @deprecated As of release 2.1, property-based class references replaced
* by container managed bean factory
*/
public JetspeedCapabilities(String repositoryPath, Properties properties)
{
super(repositoryPath);
}
/*
* Method called automatically by Spring container upon initialization
*
* @param beanFactory automatically provided by framework @throws
* BeansException
*/
public void setBeanFactory(BeanFactory beanFactory) throws BeansException
{
this.beanFactory = beanFactory;
}
private Class getClientClass() throws ClassNotFoundException
{
if (clientClass == null)
{
clientClass = createClient(null).getClass();
}
return clientClass;
}
private Class getMimeTypeClass() throws ClassNotFoundException
{
if (mimeTypeClass == null)
{
mimeTypeClass = this.createMimeType(null).getClass();
}
return mimeTypeClass;
}
private Class getCapabilityClass()throws ClassNotFoundException
{
if (capabilityClass == null)
{
capabilityClass = this.createCapability(null).getClass();
}
return capabilityClass;
}
private Class getMediaTypeClass()throws ClassNotFoundException
{
if (mediaTypeClass == null)
{
mediaTypeClass = this.createMediaType(null).getClass();
}
return mediaTypeClass;
}
/**
* @param userAgent Agent from the request
* @throws UnableToBuildCapabilityMapException
* @see org.apache.jetspeed.services.capability.CapabilityService#getCapabilityMap(java.lang.String)
*/
public CapabilityMap getCapabilityMap(String userAgent) throws UnableToBuildCapabilityMapException
{
CapabilityMap map = null;
boolean bClientFound = false;
String defaultAgent = null;
if (userAgent == null)
{
userAgent = DEFAULT_AGENT;
}
// Check the cache if we have already a capability map for
// the given Agent
map = (CapabilityMap) capabilityMapCache.get(userAgent);
if (map != null)
{
// Entry found
return map;
}
while (!bClientFound)
{
Client entry = findClient(userAgent);
if (entry == null)
{
if (userAgent.equals(DEFAULT_AGENT))
{
log.error(
"CapabilityMap: Default agent not found in Client Registry !");
// Stop searching -- event the default userAgent can't be found
bClientFound = true;
} else
{
// Retry with the default Agent
if (log.isDebugEnabled())
{
log.debug(
"CapabilityMap: useragent "
+ userAgent
+ "unknown, falling back to default");
}
// Use default Client
defaultAgent = userAgent;
userAgent = DEFAULT_AGENT;
}
} else
{
// Found Client entry start populating the capability map.
map = new CapabilityMapImpl();
// Add client to CapabilityMap
map.setClient(entry);
// Add capabilities
Iterator capabilities = entry.getCapabilities().iterator();
while (capabilities.hasNext())
{
map.addCapability((Capability) capabilities.next());
}
Collection mediatypes =
getMediaTypesForMimeTypes(entry.getMimetypes().iterator());
// Add Mimetypes to map
Iterator mimetypes = entry.getMimetypes().iterator();
while (mimetypes.hasNext())
{
map.addMimetype((MimeType) mimetypes.next());
}
Iterator media = mediatypes.iterator();
while (media.hasNext())
{
map.addMediaType((MediaType) media.next());
}
//Set preferred Mimetype
MediaType mtEntry =
getMediaTypeForMimeType(map.getPreferredType().getName());
map.setPreferredMediaType(mtEntry);
// Add map to cache
capabilityMapCache.put(userAgent, map);
if (defaultAgent != null)
capabilityMapCache.put(defaultAgent, map);
return map;
}
}
if(map != null)
{
return map;
}
else
{
throw new UnableToBuildCapabilityMapException("We were unable to build a capability map for the agent, "+userAgent+
". This might be an indiciation that the capability database has not been correctly initialized.");
}
}
/**
* Returns the client which matches the given useragent string.
*
* @param useragent the useragent to match
* @return the found client or null if the user-agent does not match any
* defined client
* @see org.apache.jetspeed.capabilities.CapabilityService#findClient(java.lang.String)
*/
public Client findClient(String userAgent)
{
Client clientEntry = null;
Iterator clients = getClients();
if (log.isDebugEnabled())
{
log.debug(
"ClientRegistry: Looking for client with useragent :"
+ userAgent);
}
while (clients.hasNext())
{
Client client = (Client) clients.next();
if (client.getUserAgentPattern() != null)
{
try
{
// Java 1.4 has regular expressions build in
String exp = client.getUserAgentPattern();
//RE r = new RE(client.getUserAgentPattern());
//r.setMatchFlags(RE.MATCH_CASEINDEPENDENT);
//if (r.match(userAgent))
if (userAgent.matches(exp))
{
if (log.isDebugEnabled())
{
log.debug(
"Client: "
+ userAgent
+ " matches "
+ client.getUserAgentPattern());
}
return client;
} else
{
if (log.isDebugEnabled())
{
log.debug(
"Client: "
+ userAgent
+ " does not match "
+ client.getUserAgentPattern());
}
}
} catch (java.util.regex.PatternSyntaxException e)
{
String message =
"CapabilityServiceImpl: UserAgentPattern not valid : "
+ client.getUserAgentPattern()
+ " : "
+ e.getMessage();
log.error(message, e);
}
}
}
return clientEntry;
}
/*
* @see org.apache.jetspeed.capabilities.CapabilityService#getClients()
*/
public Iterator getClients()
{
if (null == clients)
{
try
{
QueryByCriteria query = QueryFactory.newQuery(getClientClass(), new Criteria());
query.addOrderByAscending("evalOrder");
this.clients = getPersistenceBrokerTemplate().getCollectionByQuery(query);
}
catch (Exception e)
{
String message =
"CapabilityServiceImpl: getClients query used invalid class ";
log.error(message, e);
return null;
}
}
return this.clients.iterator();
}
/*
* @see org.apache.jetspeed.capabilities.CapabilityService#getMediaTypesForMimeTypes(java.util.Iterator)
*/
public Collection getMediaTypesForMimeTypes(Iterator mimetypes)
{
//Find the MediaType by matching the Mimetype
Criteria filter = new Criteria();
Vector temp = new Vector();
// Add Mimetypes to map and create query
while (mimetypes.hasNext())
{
MimeType mt = (MimeType) mimetypes.next();
// Add mimetype to query
// Note: mimetypes is a member of MediaTypeImpl
// criteria.addEqualTo("mimetypes.name", mt.getName());
//stuff.add(new Integer(mt.getMimetypeId()));
temp.add(mt.getName());
}
Collection co = null;
if (temp.size() > 0)
{
try
{
filter.addIn("mimetypes.name", temp);
QueryByCriteria query = QueryFactory.newQuery(getMediaTypeClass(), filter);
co = getPersistenceBrokerTemplate().getCollectionByQuery(query);
}
catch (Exception e)
{
String message =
"CapabilityServiceImpl: getMediaTypesForMimeTypes -> getMediaTypeClass query used invalid class ";
log.error(message, e);
}
}
if (co == null || co.isEmpty())
{
MediaType mt = getMediaType("html");
Vector v = new Vector();
v.add(mt);
return v;
}
return co;
}
/*
* @see org.apache.jetspeed.capabilities.CapabilityService#deleteCapabilityMapCache()
*/
public void deleteCapabilityMapCache()
{
capabilityMapCache.clear();
clients = null;
}
/* (non-Javadoc)
* @see org.apache.jetspeed.capabilities.CapabilityService#getMediaType(java.lang.String)
*/
public MediaType getMediaType(String mediaType)
{
try
{
Criteria filter = new Criteria();
filter.addEqualTo("name", mediaType);
QueryByCriteria query = QueryFactory.newQuery(getMediaTypeClass(), filter);
return (MediaType) getPersistenceBrokerTemplate().getObjectByQuery(query);
}
catch (Exception e)
{
String message =
"CapabilityServiceImpl: getMediaType query used invalid class ";
log.error(message, e);
return null;
}
}
/**
* getMediaTypeForMimeType
* @param mimeType to use for lookup
* @return MediaTypeEntry that matches the lookup in the MEDIATYPE_TO_MIMETYPE table
*/
public MediaType getMediaTypeForMimeType(String mimeTypeName)
{
//Find the MediaType by matching the Mimetype
Collection mediaTypeCollection = null;
try
{
Criteria filter = new Criteria();
filter.addEqualTo("mimetypes.name", mimeTypeName);
QueryByCriteria query = QueryFactory.newQuery(getMediaTypeClass(), filter);
mediaTypeCollection = getPersistenceBrokerTemplate().getCollectionByQuery(query);
}
catch (Exception e)
{
String message =
"CapabilityServiceImpl: getMediaTypeForMimeType query used invalid class ";
log.error(message, e);
return null;
}
Iterator mtIterator = mediaTypeCollection.iterator();
if (mtIterator.hasNext())
{
return (MediaType) mtIterator.next();
} else
{
return null;
}
}
/**
* Obtain an iterator of all existing capabilities.
* @return Returns an iterator for all existing Capabilities of type <code>Capability</code>
*/
public Iterator getCapabilities()
{
QueryByCriteria query = null;
try
{
query = QueryFactory.newQuery(getCapabilityClass(), new Criteria());
}
catch (Exception e)
{
String message =
"CapabilityServiceImpl: getCapabilities query used invalid class ";
log.error(message, e);
return null;
}
query.addOrderByAscending("name");
return getPersistenceBrokerTemplate().getCollectionByQuery(query).iterator();
}
/**
* Obtain an iterator of all existing mime types.
* @return Returns an iterator for all existing Mime Types of type <code>MimeType</code>
*/
public Iterator getMimeTypes()
{
try
{
QueryByCriteria query = QueryFactory.newQuery(getMimeTypeClass(), new Criteria());
query.addOrderByAscending("name");
return getPersistenceBrokerTemplate().getCollectionByQuery(query).iterator();
}
catch (Exception e)
{
String message =
"CapabilityServiceImpl: getMimeTypes query used invalid class ";
log.error(message, e);
return null;
}
}
/**
* Obtain an iterator of all existing media types.
* @return Returns an iterator for all existing media types of type <code>MediaType</code>
*/
public Iterator getMediaTypes()
{
try
{
QueryByCriteria query = QueryFactory.newQuery(getMediaTypeClass(), new Criteria());
query.addOrderByAscending("name");
return getPersistenceBrokerTemplate().getCollectionByQuery(query).iterator();
}
catch (Exception e)
{
String message =
"CapabilityServiceImpl: getMediaTypes query used invalid class ";
log.error(message, e);
return null;
}
}
/*
* @see org.apache.jetspeed.capabilities.Capabilities#getMimeTypeBeanName()
*/
public String getMimeTypeBeanName() {
return mimeTypeBeanName;
}
/*
* @see org.apache.jetspeed.capabilities.Capabilities#setMimeTypeBeanName(String)
*/
public void setMimeTypeBeanName(String mimeTypeBeanName) {
this.mimeTypeBeanName = mimeTypeBeanName;
}
/*
* @see org.apache.jetspeed.capabilities.Capabilities#getClientBeanName()
*/
public String getClientBeanName() {
return clientBeanName;
}
/*
* @see org.apache.jetspeed.capabilities.Capabilities#setClientBeanName(String)
*/
public void setClientBeanName(String clientBeanName) {
this.clientBeanName = clientBeanName;
}
/*
* @see org.apache.jetspeed.capabilities.Capabilities#getMediaTypeBeanName()
*/
public String getMediaTypeBeanName() {
return mediaTypeBeanName;
}
/*
* @see org.apache.jetspeed.capabilities.Capabilities#setMediaTypeBeanName(String)
*/
public void setMediaTypeBeanName(String mediaTypeBeanName) {
this.mediaTypeBeanName = mediaTypeBeanName;
}
/*
* @see org.apache.jetspeed.capabilities.Capabilities#getCapabilityBeanName()
*/
public String getCapabilityBeanName() {
return capabilityBeanName;
}
/*
* @see org.apache.jetspeed.capabilities.Capabilities#setCapabilityBeanName(String)
*/
public void setCapabilityBeanName(String capabilityBeanName) {
this.capabilityBeanName = capabilityBeanName;
}
/*
* @see org.apache.jetspeed.capabilities.Capabilities#createMimeType(String)
*/
public MimeType createMimeType(String mimeType)
throws ClassNotFoundException
{
MimeType mimeTypeobj = null;
if (mimeType != null)
{
//try to find it in space
mimeTypeobj = this.getMimeType(mimeType);
if (mimeTypeobj != null)
return mimeTypeobj;
}
try
{
mimeTypeobj = (MimeType) beanFactory.getBean(
this.mimeTypeBeanName, MimeType.class);
mimeTypeobj.setName(mimeType);
return mimeTypeobj;
} catch (Exception e)
{
log.error("Failed to create capability instance for " + this.mimeTypeBeanName
+ " error : " + e.getLocalizedMessage());
throw new ClassNotFoundException("Spring failed to create the " + this.mimeTypeBeanName
+ " mimeType bean.", e);
}
}
/*
* @see org.apache.jetspeed.capabilities.Capabilities#createCapability(String)
*/
public Capability createCapability(String capabilityName) throws ClassNotFoundException
{
Capability capability = null;
if (capabilityName != null)
{
//try to find it in space
capability = this.getCapability(capabilityName);
if (capability != null)
return capability;
}
try
{
capability = (Capability) beanFactory.getBean(
this.capabilityBeanName, Capability.class);
capability.setName(capabilityName);
return capability;
} catch (Exception e)
{
log.error("Failed to create capability instance for " + this.capabilityBeanName
+ " error : " + e.getLocalizedMessage());
throw new ClassNotFoundException("Spring failed to create the "
+ " capability bean.", e);
}
}
/*
* @see org.apache.jetspeed.capabilities.Capabilities#createMediaType(String)
*/
public MediaType createMediaType(String mediaTypeName) throws ClassNotFoundException
{
MediaType mediaType = null;
if (mediaTypeName != null)
{
//try to find it in space
mediaType = this.getMediaType(mediaTypeName);
if (mediaType != null)
return mediaType;
}
try
{
mediaType = (MediaType) beanFactory.getBean(
this.mediaTypeBeanName, MediaType.class);
mediaType.setName(mediaTypeName);
return mediaType;
} catch (Exception e)
{
log.error("Failed to create mediaType instance for " + this.mediaTypeBeanName
+ " error : " + e.getLocalizedMessage());
throw new ClassNotFoundException("Spring failed to create the "
+ " mediaType bean.", e);
}
}
/*
* @see org.apache.jetspeed.capabilities.Capabilities#createClient(String)
*/
public Client createClient(String clientName) throws ClassNotFoundException
{
Client client = null;
if (clientName != null)
{
//try to find it in space
client = this.getClient(clientName);
if (client != null)
return client;
}
try
{
client = (Client) beanFactory.getBean(
this.clientBeanName, Client.class);
client.setName(clientName);
return client;
} catch (Exception e)
{
log.error("Failed to create client instance for " + this.clientBeanName
+ " error : " + e.getLocalizedMessage());
throw new ClassNotFoundException("Spring failed to create the "
+ " client bean.", e);
}
}
/* (non-Javadoc)
* @see org.apache.jetspeed.capabilities.MimeTypeservice#getCapability(java.lang.String)
*/
public MimeType getMimeType(String mimeType)
{
try
{
Criteria filter = new Criteria();
filter.addEqualTo("name", mimeType);
QueryByCriteria query = QueryFactory.newQuery(getMimeTypeClass(), filter);
return (MimeType) getPersistenceBrokerTemplate().getObjectByQuery(query);
}
catch (Exception e)
{
String message =
"MimeTypeserviceImpl: getCapability - query for getCapabilityClass failed ";
log.error(message, e);
return null;
}
}
/* (non-Javadoc)
* @see org.apache.jetspeed.capabilities.MimeTypeservice#getClientjava.lang.String)
*/
public Client getClient(String clientName)
{
try
{
Criteria filter = new Criteria();
filter.addEqualTo("name", clientName);
QueryByCriteria query = QueryFactory.newQuery(getClientClass(), filter);
return (Client) getPersistenceBrokerTemplate().getObjectByQuery(query);
}
catch (Exception e)
{
String message =
"MimeTypeserviceImpl: getClient - query for getClientClass failed ";
log.error(message, e);
return null;
}
}
/* (non-Javadoc)
* @see org.apache.jetspeed.capabilities.MimeTypeservice#getCapability(java.lang.String)
*/
public Capability getCapability(String capability)
{
try
{
Criteria filter = new Criteria();
filter.addEqualTo("name", capability);
QueryByCriteria query = QueryFactory.newQuery(getCapabilityClass(), filter);
return (Capability) getPersistenceBrokerTemplate().getObjectByQuery(query);
}
catch (Exception e)
{
String message =
"MimeTypeserviceImpl: getCapability - query for getCapabilityClass failed ";
log.error(message, e);
return null;
}
}
/*
* (non-Javadoc)
*
* @see org.apache.jetspeed.capabilities.Capabilities#storeMediaType(MediaType)
*/
public void storeMediaType(MediaType mediaType) throws CapabilitiesException
{
//TODO: change exception to better indicate cause
getPersistenceBrokerTemplate().store(mediaType);
}
/*
* (non-Javadoc)
*
* @see org.apache.jetspeed.capabilities.Capabilities#deleteMediaType(MediaType)
*/
public void deleteMediaType(MediaType mediaType)
throws CapabilitiesException
{
//TODO: change exception to better indicate cause
getPersistenceBrokerTemplate().delete(mediaType);
}
/*
* (non-Javadoc)
*
* @see org.apache.jetspeed.capabilities.Capabilities#storeCapability(MediaType)
*/
public void storeCapability(Capability capability) throws CapabilitiesException
{
//TODO: change exception to better indicate cause
getPersistenceBrokerTemplate().store(capability);
}
/*
* (non-Javadoc)
*
* @see org.apache.jetspeed.capabilities.Capabilities#deleteCapability(Capability)
*/
public void deleteCapability(Capability capability)
throws CapabilitiesException
{
//TODO: change exception to better indicate cause
getPersistenceBrokerTemplate().delete(capability);
}
/*
* (non-Javadoc)
*
* @see org.apache.jetspeed.capabilities.Capabilities#storeMimeType(MimeType)
*/
public void storeMimeType(MimeType mimeType) throws CapabilitiesException
{
//TODO: change exception to better indicate cause
getPersistenceBrokerTemplate().store(mimeType);
}
/*
* (non-Javadoc)
*
* @see org.apache.jetspeed.capabilities.Capabilities#deleteMimeType(MimeType)
*/
public void deleteMimeType(MimeType mimeType)
throws CapabilitiesException
{
//TODO: change exception to better indicate cause
getPersistenceBrokerTemplate().delete(mimeType);
}
/*
* (non-Javadoc)
*
* @see org.apache.jetspeed.capabilities.Capabilities#storeClient(MediaType)
*/
public void storeClient(Client client) throws CapabilitiesException
{
//TODO: change exception to better indicate cause
getPersistenceBrokerTemplate().store(client);
}
/*
* (non-Javadoc)
*
* @see org.apache.jetspeed.capabilities.Capabilities#deleteClient(Client)
*/
public void deleteClient(Client client)
throws CapabilitiesException
{
//TODO: change exception to better indicate cause
getPersistenceBrokerTemplate().delete(client);
}
}