/*
* 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.wireadmin;
import java.io.PrintStream;
import java.util.Dictionary;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.Map;
import java.util.List;
import java.util.ArrayList;
import java.util.Date;
import java.util.Enumeration;
import org.osgi.framework.BundleContext;
import org.osgi.framework.Constants;
import org.osgi.framework.Filter;
import org.osgi.framework.InvalidSyntaxException;
import org.osgi.framework.ServiceEvent;
import org.osgi.framework.ServiceListener;
import org.osgi.framework.ServiceReference;
import org.osgi.service.wireadmin.Consumer;
import org.osgi.service.wireadmin.Producer;
import org.osgi.service.wireadmin.Wire;
import org.osgi.service.wireadmin.WireAdmin;
import org.osgi.service.wireadmin.WireConstants;
import org.osgi.service.wireadmin.WireAdminEvent;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileNotFoundException;
/**
* Wire Administration service.
*
* <p>This service can be used to create <tt>Wire</tt> objects connecting
* a Producer service and a Consumer service.
* <tt>Wire</tt> objects also have wire properties that may be specified
* when a <tt>Wire</tt> object is created. The Producer and Consumer
* services may use the <tt>Wire</tt> object's properties to manage or control their
* interaction.
* The use of <tt>Wire</tt> object's properties by a Producer or Consumer
* services is optional.
*
* <p>Security Considerations.
* A bundle must have <tt>ServicePermission[GET,WireAdmin]</tt> to get the Wire Admin service to
* create, modify, find, and delete <tt>Wire</tt> objects.
*
* @author <a href="mailto:dev@felix.apache.org">Felix Project Team</a>
*/
public class WireAdminImpl implements WireAdmin, ServiceListener {
private BundleContext m_bundleContext;
// A Map containing a service reference associated to a producer and a List
// of wire objects
private Map m_consumers = new HashMap(); /* ServiceReferences, List */
private Map m_producers = new HashMap(); /* ServiceReferences, List */
private List m_wires; // List containing the wires
//private BindingController wireAdminListenersBindingController;
// Filter corresponding to a consumer service
private Filter m_consumerFilter;
// Filter corresponding to a producer service
private Filter m_producerFilter;
// EventManager
private EventManager m_eventManager;
private static int m_wireCount = 0;
private AsyncMethodCaller m_asyncMethodCaller = new AsyncMethodCaller(); //m_eventDispatcher.stop();
private static PrintStream m_traceout = null;
private static PrintStream m_errorout = System.err;
/**
* Constructor with package visibility
*
* @param bundleContext the bundle context
*/
WireAdminImpl(BundleContext bundleContext)
{
m_bundleContext = bundleContext;
if(bundleContext.getProperty("fr.imag.adele.wireadmin.trace") != null)
{
String value = bundleContext.getProperty("fr.imag.adele.wireadmin.trace");
if(value.equals("true"))
{
m_traceout = System.out;
}
}
// Create the event manager (the event manager will start its own thread)
m_eventManager = new EventManager(m_bundleContext);
try
{
m_producerFilter = m_bundleContext.createFilter(
"(objectClass=org.osgi.service.wireadmin.Producer)");
m_consumerFilter = m_bundleContext.createFilter(
"(objectClass=org.osgi.service.wireadmin.Consumer)");
}
catch (InvalidSyntaxException e)
{
// never thrown since LDAP expressions are correct
}
// Recover persistent wires
getPersistentWires();
// Activate thread that does asynchronous calls to
// the producersConnected and consummersConnected methods
new Thread(m_asyncMethodCaller).start();
// Gets all producers and consumers that are present at the
// moment the wire admin is created
try
{
// Registration for events must be done first, as some service
// can be registered during initialization
m_bundleContext.addServiceListener(this,"(|"+m_producerFilter.toString()+m_consumerFilter.toString()+")");
// Replacement for the two following lines which work under OSCAR,
// but not work under IBM's SMF
//m_bundleContext.addServiceListener(this,m_consumerFilter.toString());
//m_bundleContext.addServiceListener(this,m_producerFilter.toString());
// Get all producers
ServiceReference[] producerRefs = m_bundleContext.getServiceReferences(Producer.class.getName(),null);
if(producerRefs!=null)
{
// lock the producers Map to avoid concurrent modifications due
// to service events
synchronized(m_producers)
{
for(int i=0;i<producerRefs.length;i++)
{
ServiceReference currentRef=(ServiceReference)producerRefs[i];
Iterator wireIt = m_wires.iterator();
while(wireIt.hasNext())
{
WireImpl currentWire = (WireImpl) wireIt.next();
if(currentWire.getProducerPID().equals(currentRef.getProperty(Constants.SERVICE_PID)))
{
currentWire.bindProducer(currentRef);
}
}
m_producers.put(currentRef,new ArrayList());
}
}
}
// Get all the consumers
ServiceReference[] consumerRefs = m_bundleContext.getServiceReferences(Consumer.class.getName(),null);
if(consumerRefs!=null)
{
for(int i=0;i<consumerRefs.length;i++)
{
// lock the consumers to avoid concurrent modifications due
// to service events
synchronized(m_consumers)
{
ServiceReference currentRef=(ServiceReference)consumerRefs[i];
Iterator wireIt = m_wires.iterator();
while(wireIt.hasNext())
{
WireImpl currentWire = (WireImpl) wireIt.next();
if(currentWire.getConsumerPID().equals(currentRef.getProperty(Constants.SERVICE_PID)))
{
currentWire.bindConsumer(currentRef);
}
}
m_consumers.put(currentRef,new ArrayList());
}
}
}
}
catch (InvalidSyntaxException e)
{
trace(e);
}
// Iterate over all the wires, when a wire is connected
// add it to the list of wires associated to a particular
// producer or consumer
synchronized(m_wires)
{
Iterator wireIterator = m_wires.iterator();
while(wireIterator.hasNext())
{
WireImpl currentWire = (WireImpl) wireIterator.next();
if(currentWire.isConnected())
{
// p. 327 "If both Producer and consumer services are registered
// with the framework, they are connected by the WireAdmin service"
List wires = (List) m_producers.get(currentWire.getProducerServiceRef());
wires.add(currentWire);
m_asyncMethodCaller.consumersConnected(currentWire.getProducer(),(Wire[])wires.toArray(new Wire[wires.size()]));
wires = (List) m_consumers.get(currentWire.getConsumerServiceRef());
wires.add(currentWire);
m_asyncMethodCaller.producersConnected(currentWire.getConsumer(),(Wire[])wires.toArray(new Wire[wires.size()]));
}
}
}
}
/**
* Pass the service reference to the event dispatcher
*
* @param ref the service reference
*/
void setServiceReference(ServiceReference ref)
{
m_eventManager.setServiceReference(ref);
}
/**
* Create a new <tt>Wire</tt> object that connects a Producer
* service to a Consumer service.
*
* The Producer service and Consumer service do not
* have to be registered when the <tt>Wire</tt> object is created.
*
* <p>The <tt>Wire</tt> configuration data must be persistently stored.
* All <tt>Wire</tt> connections are reestablished when the
* <tt>WireAdmin</tt> service is registered.
* A <tt>Wire</tt> can be permanently removed by using the
* {@link #deleteWire} method.
*
* <p>The <tt>Wire</tt> object's properties must have case
* insensitive <tt>String</tt> objects as keys (like the Framework).
* However, the case of the key must be preserved.
* The type of the value of the property must be one of the following:
*
* <pre>
* type = basetype
* | vector | arrays
*
* basetype = String | Integer | Long
* | Float | Double | Byte
* | Short | Character
* | Boolean
*
* primitive = long | int | short
* | char | byte | double | float
*
* arrays = primitive '[]' | basetype '[]'
*
* vector = Vector of basetype
* </pre>
*
* <p>The <tt>WireAdmin</tt> service must automatically add the
* following <tt>Wire</tt> properties:
* <ul>
* <li>
* {@link WireConstants#WIREADMIN_PID} set to the value of the <tt>Wire</tt> object's
* persistent identity (PID). This value is generated by the
* Wire Admin service when a <tt>Wire</tt> object is created.
* </li>
* <li>
* {@link WireConstants#WIREADMIN_PRODUCER_PID} set to the value of
* Producer service's PID.
* </li>
* <li>
* {@link WireConstants#WIREADMIN_CONSUMER_PID} set to the value of
* Consumer service's PID.
* </li>
* </ul>
* If the <tt>properties</tt> argument
* already contains any of these keys, then the supplied values
* are replaced with the values assigned by the Wire Admin service.
*
* <p>The Wire Admin service must broadcast a <tt>WireAdminEvent</tt> of type
* {@link WireAdminEvent#WIRE_CREATED}
* after the new <tt>Wire</tt> object becomes available from {@link #getWires}.
*
* @param producerPID The <tt>service.pid</tt> of the Producer service
* to be connected to the <tt>Wire</tt> object.
* @param consumerPID The <tt>service.pid</tt> of the Consumer service
* to be connected to the <tt>Wire</tt> object.
* @param properties The <tt>Wire</tt> object's properties. This argument may be <tt>null</tt>
* if the caller does not wish to define any <tt>Wire</tt> object's properties.
* @return The <tt>Wire</tt> object for this connection.
* @throws java.lang.IllegalArgumentException If
* <tt>properties</tt> contains case variants of the same key name.
*/
public Wire createWire(String producerPID, String consumerPID, Dictionary props)
{
ServiceReference producerServiceRef = null;
ServiceReference consumerServiceRef = null;
Dictionary properties;
if(props == null)
{
properties = new Hashtable();
}
else
{
//Clone the dictionary
properties = cloneProperties(props);
}
// Addition of mandatory properties
properties.put(WireConstants.WIREADMIN_CONSUMER_PID, consumerPID);
properties.put(WireConstants.WIREADMIN_PRODUCER_PID, producerPID);
properties.put(WireConstants.WIREADMIN_PID, generateWirePID());
// p.327 "Wire objects can be created when the producer or consumer
// service is not registered
WireImpl wire = new WireImpl(producerPID, consumerPID, properties);
// Initialize the wire
wire.initialize(m_bundleContext,m_eventManager);
// Add the wire to the list
synchronized(m_wires)
{
m_wires.add(wire);
}
// p. 357 "The Wire Admin service must broadcast a WireAdminEvent of
// type WireAdminEvent.WIRE_CREATED after the new Wire object becomes
// available from getWires(java.lang.String)."
m_eventManager.fireEvent(WireAdminEvent.WIRE_CREATED,wire);
synchronized (m_producers)
{
Iterator producerIterator = m_producers.keySet().iterator();
while(producerIterator.hasNext())
{
producerServiceRef = (ServiceReference) producerIterator.next();
if (producerServiceRef.getProperty(Constants.SERVICE_PID).equals(producerPID))
{
wire.bindProducer(producerServiceRef);
break;
}
}
}
synchronized (m_consumers)
{
Iterator consumerIterator = m_consumers.keySet().iterator();
while(consumerIterator.hasNext())
{
consumerServiceRef = (ServiceReference) consumerIterator.next();
if (consumerServiceRef.getProperty(Constants.SERVICE_PID).equals(consumerPID))
{
wire.bindConsumer(consumerServiceRef);
break;
}
}
}
// p.327 If both Producer and Consumer services are registered, they are
// connected by the wire admin service.
if(wire.isConnected())
{
List wires = (List) m_producers.get(producerServiceRef);
wires.add(wire);
m_asyncMethodCaller.consumersConnected(wire.getProducer(),(Wire[])wires.toArray(new Wire[wires.size()]));
wires = (List) m_consumers.get(consumerServiceRef);
wires.add(wire);
m_asyncMethodCaller.producersConnected(wire.getConsumer(),(Wire[])wires.toArray(new Wire[wires.size()]));
}
// Newly created wires are immediately persisted to avoid information
// loss in case of crashes. (spec not clear about this)
persistWires();
return wire;
}
/**
* Delete a <tt>Wire</tt> object.
*
* <p>The <tt>Wire</tt> object representing a connection between
* a Producer service and a Consumer service must be
* removed.
* The persistently stored configuration data for the <tt>Wire</tt> object
* must destroyed. The <tt>Wire</tt> object's method {@link Wire#isValid} will return <tt>false</tt>
* after it is deleted.
*
* <p>The Wire Admin service must broadcast a <tt>WireAdminEvent</tt> of type
* {@link WireAdminEvent#WIRE_DELETED}
* after the <tt>Wire</tt> object becomes invalid.
*
* @param wire The <tt>Wire</tt> object which is to be deleted.
*/
public void deleteWire(Wire wire)
{
if(m_wires.contains(wire))
{
WireImpl wireImpl = (WireImpl) wire;
m_wires.remove(wire);
if(wireImpl.isConnected())
{
List wires = (List) m_producers.get(wireImpl.getProducerServiceRef());
wires.remove(wireImpl);
m_asyncMethodCaller.consumersConnected(wireImpl.getProducer(),(Wire[])wires.toArray(new Wire[wires.size()]));
wires = (List) m_consumers.get(wireImpl.getConsumerServiceRef());
wires.remove(wireImpl);
m_asyncMethodCaller.producersConnected(wireImpl.getConsumer(),(Wire[])wires.toArray(new Wire[wires.size()]));
}
wireImpl.invalidate();
// fire an event
m_eventManager.fireEvent(WireAdminEvent.WIRE_DELETED,wireImpl);
// Persist state to avoid losses in case of crashes (spec not clear about this).
persistWires();
}
else
{
traceln("WireAdminImpl: Cannot delete a wire that is not managed by this service");
}
}
/**
* Update the properties of a <tt>Wire</tt> object.
*
* The persistently stored configuration data for the <tt>Wire</tt> object
* is updated with the new properties and then the Consumer and Producer
* services will be called at the respective {@link Consumer#producersConnected}
* and {@link Producer#consumersConnected} methods.
*
* <p>The Wire Admin service must broadcast a <tt>WireAdminEvent</tt> of type
* {@link WireAdminEvent#WIRE_UPDATED}
* after the updated properties are available from the <tt>Wire</tt> object.
*
* @param wire The <tt>Wire</tt> object which is to be updated.
* @param properties The new <tt>Wire</tt> object's properties or <tt>null</tt> if no properties are required.
*/
public void updateWire(Wire wire, Dictionary props)
{
if(m_wires.contains(wire) == false)
{
traceln("WireAdminImpl: Cannot update a wire that is not managed by this service");
return;
}
// Clone the dictionary
Dictionary properties = cloneProperties(props);
// Put again the mandatory properties, in case they are not set
properties.put(WireConstants.WIREADMIN_CONSUMER_PID,wire.getProperties().get(WireConstants.WIREADMIN_CONSUMER_PID));
properties.put(WireConstants.WIREADMIN_PRODUCER_PID,wire.getProperties().get(WireConstants.WIREADMIN_PRODUCER_PID));
properties.put(WireConstants.WIREADMIN_PID,wire.getProperties().get(WireConstants.WIREADMIN_PID));
WireImpl wireImpl = (WireImpl) wire;
wireImpl.updateProperties(properties);
// Call methods on Consumer and Producer
if(wireImpl.isConnected())
{
List wires = (List) m_producers.get(wireImpl.getProducerServiceRef());
m_asyncMethodCaller.consumersConnected(wireImpl.getProducer(),(Wire[])wires.toArray(new Wire[wires.size()]));
wires = (List) m_consumers.get(wireImpl.getConsumerServiceRef());
m_asyncMethodCaller.producersConnected(wireImpl.getConsumer(),(Wire[])wires.toArray(new Wire[wires.size()]));
}
// fire an event
m_eventManager.fireEvent(WireAdminEvent.WIRE_UPDATED,wireImpl);
}
/**
* Return the <tt>Wire</tt> objects that match the given <tt>filter</tt>.
*
* <p>The list of available <tt>Wire</tt> objects is matched against the
* specified <tt>filter</tt>. <tt>Wire</tt> objects which match the
* <tt>filter</tt> must be returned. These <tt>Wire</tt> objects are not necessarily
* connected. The Wire Admin service should not return
* invalid <tt>Wire</tt> objects, but it is possible that a <tt>Wire</tt>
* object is deleted after it was placed in the list.
*
* <p>The filter matches against the <tt>Wire</tt> object's properties including
* {@link WireConstants#WIREADMIN_PRODUCER_PID}, {@link WireConstants#WIREADMIN_CONSUMER_PID}
* and {@link WireConstants#WIREADMIN_PID}.
*
* @param filter Filter string to select <tt>Wire</tt> objects
* or <tt>null</tt> to select all <tt>Wire</tt> objects.
* @return An array of <tt>Wire</tt> objects which match the <tt>filter</tt>
* or <tt>null</tt> if no <tt>Wire</tt> objects match the <tt>filter</tt>.
* @throws org.osgi.framework.InvalidSyntaxException If the specified <tt>filter</tt>
* has an invalid syntax.
* @see org.osgi.framework.Filter
*/
public Wire[] getWires(String filter) throws InvalidSyntaxException
{
List res = null;
if (filter == null)
{
return (Wire [])m_wires.toArray(new Wire[m_wires.size()]);
}
else
{
Filter tempFilter = m_bundleContext.createFilter(filter);
Iterator iter = m_wires.iterator();
while (iter.hasNext())
{
WireImpl currentWire = (WireImpl) iter.next();
if (tempFilter.match(currentWire.getProperties()))
{
if (res == null)
{
res = new ArrayList();
}
res.add(currentWire);
}
}
}
if (res == null)
{
return null;
}
else
{
return (Wire [])res.toArray(new Wire[res.size()]);
}
}
/**
* listens Producer and Consumer services changes
* @see org.osgi.framework.ServiceListener#serviceChanged(org.osgi.framework.ServiceEvent)
*/
public void serviceChanged(ServiceEvent e)
{
ServiceReference serviceRef = e.getServiceReference();
// A consumer service changed
if (m_consumerFilter.match(serviceRef))
{
switch (e.getType())
{
case ServiceEvent.REGISTERED :
traceln("consumer registered");
List wires = new ArrayList();
synchronized(m_consumers)
{
m_consumers.put(serviceRef,wires);
}
synchronized(m_wires)
{
Iterator wireIt = m_wires.iterator();
boolean called = false;
// Iterate over all existing wires
while(wireIt.hasNext())
{
WireImpl currentWire = (WireImpl) wireIt.next();
if(currentWire.getConsumerPID().equals(serviceRef.getProperty(Constants.SERVICE_PID)))
{
// This wire is associated to the newly arrived consumer
currentWire.bindConsumer(serviceRef);
if(currentWire.isConnected())
{
// The wire has been connected, both producer and consumer
// must be updated
wires.add(currentWire);
called = true;
m_asyncMethodCaller.producersConnected(currentWire.getConsumer(),(Wire[])wires.toArray(new Wire[wires.size()]));
List producerWires = (List) m_producers.get(currentWire.getProducerServiceRef());
producerWires.add(currentWire);
m_asyncMethodCaller.consumersConnected(currentWire.getProducer(),(Wire[])producerWires.toArray(new Wire[producerWires.size()]));
}
}
}
if(!called)
{
// P. 329 "If the Consumer service has no Wire objects attached when it
// is registered, the WireAdmin service must always call producersConnected(null)
m_asyncMethodCaller.producersConnected((Consumer) m_bundleContext.getService(serviceRef),null);
}
}
break;
case ServiceEvent.UNREGISTERING :
traceln("consumer unregistering");
synchronized(m_consumers)
{
m_consumers.remove(serviceRef);
}
synchronized(m_wires)
{
Iterator wireIt = m_wires.iterator();
while(wireIt.hasNext())
{
WireImpl currentWire = (WireImpl) wireIt.next();
if(currentWire.getConsumerPID().equals(serviceRef.getProperty(Constants.SERVICE_PID)))
{
// p. 328 "When a Consumer or Producer service is unregistered
// from the OSGi framework, the other object in the association
// is informed that the Wire object is no longer valid"
if(currentWire.isConnected())
{
currentWire.unbindConsumer();
List producerWires = (List) m_producers.get(currentWire.getProducerServiceRef());
producerWires.remove(currentWire);
m_asyncMethodCaller.consumersConnected(currentWire.getProducer(),(Wire[])producerWires.toArray(new Wire[producerWires.size()]));
}
else
{
currentWire.unbindConsumer();
}
}
}
}
break;
case ServiceEvent.MODIFIED :
// TODO Respond to consumer service modification
traceln("consumer service modified");
break;
}
}
// Removed else to manage services which are both producers AND consumers
if (m_producerFilter.match(serviceRef))
{
switch (e.getType())
{
case ServiceEvent.REGISTERED :
traceln("producer registered");
List wires = new ArrayList();
synchronized(m_producers)
{
m_producers.put(serviceRef,wires);
}
synchronized(m_wires)
{
Iterator wireIt = m_wires.iterator();
boolean called = false;
// Iterate over all existing wires
while(wireIt.hasNext())
{
WireImpl currentWire = (WireImpl) wireIt.next();
if(currentWire.getProducerPID().equals(serviceRef.getProperty(Constants.SERVICE_PID)))
{
// This wire is associated to the newly arrived producer
currentWire.bindProducer(serviceRef);
if(currentWire.isConnected())
{
// The wire has been connected, both producer and consumer
// must be updated
wires.add(currentWire);
called = true;
m_asyncMethodCaller.consumersConnected(currentWire.getProducer(),(Wire[])wires.toArray(new Wire[wires.size()]));
List consumerWires = (List) m_consumers.get(currentWire.getConsumerServiceRef());
consumerWires.add(currentWire);
m_asyncMethodCaller.producersConnected(currentWire.getConsumer(),(Wire[])consumerWires.toArray(new Wire[consumerWires.size()]));
}
}
}
if(!called)
{
// P. 329 "If the Producer service has no Wire objects attached when it
// is registered, the WireAdmin service must always call consumersConnected(null)
m_asyncMethodCaller.consumersConnected((Producer) m_bundleContext.getService(serviceRef),null);
}
}
break;
case ServiceEvent.UNREGISTERING :
traceln("Producer unregistering");
synchronized(m_producers)
{
m_producers.remove(serviceRef);
}
synchronized(m_wires)
{
Iterator wireIt = m_wires.iterator();
while(wireIt.hasNext())
{
WireImpl currentWire = (WireImpl) wireIt.next();
if(currentWire.getProducerPID().equals(serviceRef.getProperty(Constants.SERVICE_PID)))
{
// p. 328 "When a Consumer or Producer service is unregistered
// from the OSGi framework, the other object in the association
// is informed that the Wire object is no longer valid"
if(currentWire.isConnected())
{
currentWire.unbindProducer();
List consumerWires = (List) m_consumers.get(currentWire.getConsumerServiceRef());
consumerWires.remove(currentWire);
m_asyncMethodCaller.producersConnected(currentWire.getConsumer(),(Wire[])consumerWires.toArray(new Wire[consumerWires.size()]));
}
else
{
currentWire.unbindProducer();
}
}
}
}
break;
case ServiceEvent.MODIFIED :
// TODO Respond to producer service modification
traceln("producer service modified");
break;
}
}
}
/**
* release all references before stop
*/
synchronized void releaseAll()
{
Iterator wireIt = m_wires.iterator();
while(wireIt.hasNext())
{
WireImpl currentWire = (WireImpl) wireIt.next();
currentWire.invalidate();
}
Iterator producerIt = m_producers.keySet().iterator();
while (producerIt.hasNext())
{
ServiceReference producerRef = (ServiceReference) producerIt.next();
((Producer)m_bundleContext.getService(producerRef)).consumersConnected(null);
}
Iterator consumerIt = m_consumers.keySet().iterator();
while (consumerIt.hasNext())
{
ServiceReference consumerRef = (ServiceReference) consumerIt.next();
((Consumer)m_bundleContext.getService(consumerRef)).producersConnected(null);
}
// Stop the thread
m_asyncMethodCaller.stop();
// Notify the event manager so that it stops its thread
m_eventManager.stop();
persistWires();
}
/**
* This method generates a PID. The pid is generated from the bundle id,
* a hash code from the current time and a counter.
*
* @return a wire PID
*/
private String generateWirePID()
{
Date d = new Date();
String PID="wire."+m_bundleContext.getBundle().getBundleId()+d.hashCode()+m_wireCount;
m_wireCount ++;
// Maybe the counter should go above 9?
if(m_wireCount>9)
{
m_wireCount = 0;
}
return PID;
}
/**
* Recover persistent wires
*
*/
private void getPersistentWires()
{
try
{
ObjectInputStream ois = new ObjectInputStream(new FileInputStream(m_bundleContext.getDataFile("wires.ser")));
m_wires = (ArrayList) ois.readObject();
ois.close();
if(m_wires!=null)
{
traceln("Deserialized "+m_wires.size()+" wires");
Iterator wireIt = m_wires.iterator();
while(wireIt.hasNext())
{
WireImpl currentWire = (WireImpl) wireIt.next();
currentWire.initialize(m_bundleContext,m_eventManager);
}
}
else
{
traceln("Couldn't Deserialize wires");
m_wires = new ArrayList();
}
}
catch(FileNotFoundException ex)
{
// do not show anything as this exception is thrown every
// time the wire admin service is launched for the first
// time
m_wires = new ArrayList();
}
catch(Exception ex)
{
trace(ex);
m_wires = new ArrayList();
}
}
/**
* Persist existing wires
*
*/
private void persistWires()
{
try
{
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(m_bundleContext.getDataFile("wires.ser")));
oos.writeObject(m_wires);
oos.close();
traceln("Serialized "+m_wires.size()+" wires");
}
catch(Exception ex)
{
trace(ex);
}
}
/**
* print an error
* @param message message to error
*/
static void error(String message)
{
if (m_errorout != null)
{
m_errorout.println(message);
}
}
/**
* print a trace
* @param message message to trace
*/
static void traceln(String message)
{
if (m_traceout != null)
{
trace(message);
trace("\n");
}
}
/**
* print a trace
* @param message message to trace
*/
static void trace(String message)
{
if (m_traceout != null)
{
m_traceout.print(message);
}
}
/**
* print a trace
* @param e exception to trace
*/
static void trace(Exception e)
{
if (m_traceout != null)
{
e.printStackTrace(m_traceout);
}
}
/**
* Clone a dictionary
*
* @param dictionary The dictionary to clone
* @return a copy of the dicionary
*/
private Dictionary cloneProperties(Dictionary dictionary){
Dictionary properties=new Hashtable();
if (dictionary == null) {
properties = new Hashtable();
} else {
Enumeration enumeration=dictionary.keys();
while(enumeration.hasMoreElements()){
Object key=enumeration.nextElement();
Object value=dictionary.get(key);
properties.put(key,value);
}
}
return properties;
}
/**
* This class enables calls to Producer.consumersConnected and Consumer.producersConnected
* to be done asynchronously
*
* p.333 "The WireAdmin service can call the consumersConnected or producersConnected
* methods during the registration of the consumer of producer service"
*
**/
class AsyncMethodCaller implements Runnable
{
private boolean m_stop = false;
private List m_methodCallStack = new ArrayList();
public void run()
{
while (!m_stop)
{
Object nextTarget[] = null;
synchronized (m_methodCallStack)
{
while (m_methodCallStack.size() == 0)
{
try
{
m_methodCallStack.wait();
}
catch (InterruptedException ex)
{
// Ignore.
}
}
nextTarget = (Object[]) m_methodCallStack.remove(0);
}
if(nextTarget[0] instanceof Producer)
{
try
{
((Producer)nextTarget[0]).consumersConnected((Wire[])nextTarget[1]);
}
catch(Exception ex)
{
trace(ex);
}
}
// Removed else because nextTarget can be both producer and consumer
if(nextTarget[0] instanceof Consumer)
{
try
{
((Consumer)nextTarget[0]).producersConnected((Wire[])nextTarget[1]);
}
catch(Exception ex)
{
trace(ex);
}
}
}
}
/**
* Place a call to Consumer.producersConnected on the stack
*
* @param c the consumer
* @param wires the wires
*/
public void producersConnected(Consumer c,Wire []wires)
{
synchronized (m_methodCallStack)
{
m_methodCallStack.add(new Object[]{c,wires});
m_methodCallStack.notify();
}
}
/**
* Place a call to Producer.consumersConnected on the stack
*
* @param p the producer
* @param wires the wires
*/
public void consumersConnected(Producer p,Wire []wires)
{
synchronized (m_methodCallStack)
{
m_methodCallStack.add(new Object[]{p,wires});
m_methodCallStack.notify();
}
}
/**
* stop the dispatcher
*
*/
void stop()
{
m_stop = true;
}
}
}