/*
* 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.felix.webconsole.internal.configuration;
import java.io.IOException;
import java.util.Arrays;
import java.util.Collections;
import java.util.Dictionary;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.apache.felix.utils.json.JSONWriter;
import org.osgi.framework.Bundle;
import org.osgi.framework.BundleContext;
import org.osgi.service.cm.Configuration;
import org.osgi.service.metatype.AttributeDefinition;
import org.osgi.service.metatype.MetaTypeInformation;
import org.osgi.service.metatype.MetaTypeService;
import org.osgi.service.metatype.ObjectClassDefinition;
/**
* The <code>ConfigManagerBase</code> is the base class for the
* ConfigurationAdmin support in the web console. It provides various helper
* methods mostly with respect to using the MetaTypeService to access
* configuration descriptions.
*/
class MetaTypeServiceSupport extends MetaTypeSupport
{
private final BundleContext bundleContext;
private final MetaTypeService service;
/**
*
* @param bundleContext
* @param service
*
* @throws ClassCastException if {@code service} is not a MetaTypeService instances
*/
MetaTypeServiceSupport( final BundleContext bundleContext, final Object service )
{
super();
this.bundleContext = bundleContext;
this.service = ( MetaTypeService ) service;
}
public BundleContext getBundleContext()
{
return bundleContext;
}
public MetaTypeService getMetaTypeService()
{
return service;
}
/**
* Returns a map of PIDs and providing bundles of MetaType information. The
* map is indexed by PID and the value of each entry is the bundle providing
* the MetaType information for that PID.
*
* @param locale The name of the locale to get the meta data for.
* @return see the method description
*/
Map getPidObjectClasses( final String locale )
{
return getObjectClassDefinitions( PID_GETTER, locale );
}
/**
* Returns a map of factory PIDs and providing bundles of MetaType
* information. The map is indexed by factory PID and the value of each
* entry is the bundle providing the MetaType information for that factory
* PID.
*
* @param locale The name of the locale to get the meta data for.
* @return see the method description
*/
Map getFactoryPidObjectClasses( final String locale )
{
return getObjectClassDefinitions( FACTORY_PID_GETTER, locale );
}
/**
* Returns the <code>ObjectClassDefinition</code> objects for the IDs
* returned by the <code>idGetter</code>. Depending on the
* <code>idGetter</code> implementation this will be for factory PIDs or
* plain PIDs.
*
* @param idGetter The {@link IdGetter} used to get the list of factory PIDs
* or PIDs from <code>MetaTypeInformation</code> objects.
* @param locale The name of the locale to get the object class definitions
* for.
* @return Map of <code>ObjectClassDefinition</code> objects indexed by the
* PID (or factory PID) to which they pertain
*/
private Map getObjectClassDefinitions( final IdGetter idGetter, final String locale )
{
final Map objectClassesDefinitions = new HashMap();
final MetaTypeService mts = this.getMetaTypeService();
if ( mts != null )
{
final Bundle[] bundles = this.getBundleContext().getBundles();
for ( int i = 0; i < bundles.length; i++ )
{
final MetaTypeInformation mti = mts.getMetaTypeInformation( bundles[i] );
if ( mti != null )
{
final String[] idList = idGetter.getIds( mti );
for ( int j = 0; idList != null && j < idList.length; j++ )
{
// After getting the list of PIDs, a configuration might be
// removed. So the getObjectClassDefinition will throw
// an exception, and this will prevent ALL configuration from
// being displayed. By catching it, the configurations will be
// visible
ObjectClassDefinition ocd = null;
try
{
ocd = mti.getObjectClassDefinition( idList[j], locale );
}
catch ( IllegalArgumentException ignore )
{
// ignore - just don't show this configuration
}
if ( ocd != null )
{
objectClassesDefinitions.put( idList[j], ocd );
}
}
}
}
}
return objectClassesDefinitions;
}
ObjectClassDefinition getObjectClassDefinition( Configuration config, String locale )
{
// if the configuration is bound, try to get the object class
// definition from the bundle installed from the given location
if ( config.getBundleLocation() != null )
{
Bundle bundle = getBundle( this.getBundleContext(), config.getBundleLocation() );
if ( bundle != null )
{
String id = config.getFactoryPid();
if ( null == id )
{
id = config.getPid();
}
return getObjectClassDefinition( bundle, id, locale );
}
}
// get here if the configuration is not bound or if no
// bundle with the bound location is installed. We search
// all bundles for a matching [factory] PID
// if the configuration is a factory one, use the factory PID
if ( config.getFactoryPid() != null )
{
return this.getObjectClassDefinition( config.getFactoryPid(), locale );
}
// otherwise use the configuration PID
return this.getObjectClassDefinition( config.getPid(), locale );
}
ObjectClassDefinition getObjectClassDefinition( Bundle bundle, String pid, String locale )
{
if ( bundle != null )
{
MetaTypeService mts = this.getMetaTypeService();
if ( mts != null )
{
MetaTypeInformation mti = mts.getMetaTypeInformation( bundle );
if ( mti != null )
{
// see #getObjectClasses( final IdGetter idGetter, final String locale )
try
{
return mti.getObjectClassDefinition( pid, locale );
}
catch ( IllegalArgumentException e )
{
// MetaTypeProvider.getObjectClassDefinition might throw illegal
// argument exception. So we must catch it here, otherwise the
// other configurations will not be shown
// See https://issues.apache.org/jira/browse/FELIX-2390
// https://issues.apache.org/jira/browse/FELIX-3694
}
}
}
}
// fallback to nothing found
return null;
}
ObjectClassDefinition getObjectClassDefinition( String pid, String locale )
{
Bundle[] bundles = this.getBundleContext().getBundles();
for ( int i = 0; i < bundles.length; i++ )
{
try
{
ObjectClassDefinition ocd = this.getObjectClassDefinition( bundles[i], pid, locale );
if ( ocd != null )
{
return ocd;
}
}
catch ( IllegalArgumentException iae )
{
// don't care
}
}
return null;
}
Map getAttributeDefinitionMap( Configuration config, String locale )
{
Map adMap = new HashMap();
ObjectClassDefinition ocd = this.getObjectClassDefinition( config, locale );
if ( ocd != null )
{
AttributeDefinition[] ad = ocd.getAttributeDefinitions( ObjectClassDefinition.ALL );
if ( ad != null )
{
for ( int i = 0; i < ad.length; i++ )
{
adMap.put( ad[i].getID(), new MetatypePropertyDescriptor( ad[i], false ) );
}
}
}
return adMap;
}
void mergeWithMetaType( Dictionary props, ObjectClassDefinition ocd, JSONWriter json, Set ignoreAttrIds )
throws IOException
{
json.key( "title" ).value( ocd.getName() ); //$NON-NLS-1$
if ( ocd.getDescription() != null )
{
json.key( "description" ).value( ocd.getDescription() ); //$NON-NLS-1$
}
AttributeDefinition[] ad = ocd.getAttributeDefinitions( ObjectClassDefinition.ALL );
AttributeDefinition[] optionalArray = ocd.getAttributeDefinitions( ObjectClassDefinition.OPTIONAL );
List/*<AttributeDefinition>*/ optional = optionalArray == null ? Collections.EMPTY_LIST : Arrays.asList( optionalArray );
final Set metatypeAttributes = new HashSet(ignoreAttrIds);
if ( ad != null )
{
json.key( "properties" ).object(); //$NON-NLS-1$
for ( int i = 0; i < ad.length; i++ )
{
final AttributeDefinition adi = ad[i];
final String attrId = adi.getID();
if (!ignoreAttrIds.contains(attrId)) {
json.key( attrId );
boolean isOptional = optional.contains( adi );
attributeToJson( json, new MetatypePropertyDescriptor( adi, isOptional ), props.get( attrId ) );
}
metatypeAttributes.add( attrId );
}
json.endObject();
}
final StringBuffer sb = new StringBuffer();
final Enumeration e = props.keys();
while ( e.hasMoreElements() )
{
String key = (String)e.nextElement();
if ( !metatypeAttributes.contains(key) ) {
if ( sb.length() > 0 )
{
sb.append(',');
}
sb.append(key);
}
}
if ( sb.length() > 0 )
{
json.key("additionalProperties").value(sb.toString());
}
}
/**
* The <code>IdGetter</code> interface is an internal helper to abstract
* retrieving object class definitions from all bundles for either
* pids or factory pids.
*
* @see #PID_GETTER
* @see #FACTORY_PID_GETTER
*/
private static interface IdGetter
{
String[] getIds( MetaTypeInformation metaTypeInformation );
}
/**
* The implementation of the {@link IdGetter} interface returning the PIDs
* listed in the meta type information.
*
* @see #getPidObjectClasses(String)
*/
private static final IdGetter PID_GETTER = new IdGetter()
{
public String[] getIds( MetaTypeInformation metaTypeInformation )
{
return metaTypeInformation.getPids();
}
};
/**
* The implementation of the {@link IdGetter} interface returning the
* factory PIDs listed in the meta type information.
*
* @see #getFactoryPidObjectClasses(String)
*/
private static final IdGetter FACTORY_PID_GETTER = new IdGetter()
{
public String[] getIds( MetaTypeInformation metaTypeInformation )
{
return metaTypeInformation.getFactoryPids();
}
};
}