The ServerMetadataPlugin class combines the functionality of a Metadata Plugin - it registers an com.prosyst.mbs.services.metatype.MetaDataPlugin, and of a metadata management application – it listens for changed XML-defined metadata and for Metatype Provider services with registration property "metadata.type" equal to "Server". On detecting changes, the ServerMedataPlugin class checks the "isServer" and "port" attributes and logs the result.

Listing 1. An example Metadata Plugin.

import java.io.IOException;
import java.util.Hashtable;
import java.util.Vector;

import com.prosyst.mbs.services.metatype.MetaDataListener;
import com.prosyst.mbs.services.metatype.MetaDataManager;
import com.prosyst.mbs.services.metatype.MetaDataPlugin;
import com.prosyst.mbs.services.metatype.MetaTypeProviderExtern;
import org.osgi.framework.BundleActivator;
import org.osgi.framework.BundleContext;
import org.osgi.framework.Constants;
import org.osgi.framework.ServiceEvent;
import org.osgi.framework.ServiceListener;
import org.osgi.framework.ServiceReference;
import org.osgi.framework.ServiceRegistration;
import org.osgi.service.metatype.AttributeDefinition;
import org.osgi.service.metatype.MetaTypeProvider;
import org.osgi.service.metatype.ObjectClassDefinition;

import com.prosyst.util.ref.Log;

public class ServerMetadataPlugin
         implements MetaDataPlugin, BundleActivator, ServiceListener, MetaDataListener {
  
  // Represents the "Server" metadata type
  public static final String METATYPE = "Server";
  
  // Represent managed attributes
  private static final String SERVER_ATTRIBUTE_NAME = "isServer";
  private static final String PORT_ATTRIBUTE_NAME = "port";
  
  ServiceRegistration sReg = null;

  ServiceReference mdataMngrRef = null;
  MetaDataManager mdataMngr = null;

  Log log = null;
  
  // Method inherited from MetaDataPlugin
  public boolean processed(String type) {
    return true;
  }
  
  // Methods inherited from BundleActivator
  public void start(BundleContext bc) throws Exception {
    // Initializing the log reference utility
    log = new Log(bc);
    log.setPrintOnConsole(true);
    // Registering Metadata Plugin for the "Server" type
    Hashtable sProps = new Hashtable();
    sProps.put(METADATA, METATYPE);
    sReg = bc.registerService(MetaDataPlugin.class.getName(), this, sProps);
    // Getting the Metadata Manager
    mdataMngrRef = bc.getServiceReference(MetaDataManager.class.getName());
    if (mdataMngrRef != null) {
      mdataMngr = (MetaDataManager) bc.getService(mdataMngrRef);
      // Adding a listener for XML-formatted metadata changes
      mdataMngr.addMetaDataListener(this, new String[] { METATYPE });
    }
    // Checking and registering a listener for Metatype Providers
    ServiceReference[] mdataProviders =
      bc.getServiceReferences(MetaTypeProvider.class.getName(),
                              "(metadata.type=" + METATYPE + ")");
    boolean iterateProviders = false;
    if (mdataProviders != null) {
      iterateProviders = true;
    }
    for (int i = 0; iterateProviders && (i < mdataProviders.length); i++) {    
      if (mdataProviders[i].getProperty(Constants.SERVICE_PID) != null) {
        // Processing available Metatype Providers
        processMetadata((String) mdataProviders[i].getProperty(Constants.SERVICE_PID));
      }      
    }
    bc.addServiceListener(
         this,
         "(&(" + Constants.OBJECTCLASS + "=" + MetaTypeProvider.class.getName() +
         ")(metadata.type=" + METATYPE + "))");
  }
      
  public void stop(BundleContext bc) throws Exception {
    if (sReg != null) {
      sReg.unregister();
    }
    mdataMngr.removeMetaDataListener(this);
  }
  
  // Method inherited from ServiceListener
  public void serviceChanged(ServiceEvent serviceEvent) {
    int eventType = serviceEvent.getType();
    // Processing new and changed Metatype Providers
    if ((eventType == ServiceEvent.REGISTERED) || (eventType == ServiceEvent.MODIFIED)) {
      ServiceReference mtpRef = serviceEvent.getServiceReference();
      String servicePid = (String) mtpRef.getProperty(Constants.SERVICE_PID);
      try {
        if (servicePid != null) {
          processMetadata(servicePid);
        }
      } catch (IOException e) {
        e.printStackTrace();
      }      
    }
  }
    
  // Checks if the metadata refers to a server or to a client and prints the result
  // through the log utility
  private void processMetadata(String servicePid) throws IOException {
    String header = "Entity with metatype ID " + servicePid;
    AttributeDefinition adServer = null;
    AttributeDefinition adPort = null;
    MetaTypeProviderExtern mtp = mdataMngr.getMetaTypeProvider(servicePid, true);
    ObjectClassDefinition ocd = mtp.getObjectClassDefinition(servicePid, null);
    AttributeDefinition[] attrDefs = ocd.getAttributeDefinitions(ObjectClassDefinition.ALL);
    for (int i = 0; i < attrDefs.length; i++) {
      if ((attrDefs[i].getID()).equals(SERVER_ATTRIBUTE_NAME)) {
        adServer = attrDefs[i];
      }
      if ((attrDefs[i].getID()).equals(PORT_ATTRIBUTE_NAME)) {
        adPort = attrDefs[i];
      }
    }
    if ((adPort != null) && (adServer != null)) {
      if ((adServer.getDefaultValue()[0]).equals("true")) {
        log.info(header + " is a server listening on port " + adPort.getDefaultValue()[0]);
      } else {
        log.info(header + " is a client using port " +
                 adPort.getDefaultValue()[0] + " for connection");
      }
    }
  }
  
  // Method inherited from MetaDataListener
  public void metaDataChanged(int event, long bundleId,
                              String type, String pid,
                              String version, int sourceType) {
    try {
      // Processing new or changed XML metadata
      if ((event == ADDED) || (event == UPDATED)) {
        processMetadata(pid);
      }
    } catch (Exception e) {
      e.printStackTrace();
    }
  }
}