| /* |
| * 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.util.Dictionary; |
| import java.util.Enumeration; |
| import java.util.Vector; |
| import java.util.Date; |
| |
| import org.osgi.framework.Filter; |
| import org.osgi.framework.BundleContext; |
| import org.osgi.framework.ServiceReference; |
| import org.osgi.framework.Constants; |
| import org.osgi.framework.InvalidSyntaxException; |
| |
| import org.osgi.service.wireadmin.Consumer; |
| import org.osgi.service.wireadmin.Producer; |
| import org.osgi.service.wireadmin.Wire; |
| import org.osgi.service.wireadmin.WireConstants; |
| import org.osgi.service.wireadmin.WireAdminEvent; |
| |
| /** |
| * A connection between a Producer service and a Consumer service. |
| * |
| * <p>A <tt>Wire</tt> object connects a Producer service |
| * to a Consumer service. |
| * Both the Producer and Consumer services are identified |
| * by their unique <tt>service.pid</tt> values. |
| * The Producer and Consumer services may communicate with |
| * each other via <tt>Wire</tt> objects that connect them. |
| * The Producer service may send updated values to the |
| * Consumer service by calling the {@link #update} method. |
| * The Consumer service may request an updated value from the |
| * Producer service by calling the {@link #poll} method. |
| * |
| * <p>A Producer service and a Consumer service may be |
| * connected through multiple <tt>Wire</tt> objects. |
| * |
| * <p>Security Considerations. <tt>Wire</tt> objects are available to |
| * Producer and Consumer services connected to a given |
| * <tt>Wire</tt> object and to bundles which can access the <tt>WireAdmin</tt> service. |
| * A bundle must have <tt>ServicePermission[GET,WireAdmin]</tt> to get the <tt>WireAdmin</tt> service to |
| * access all <tt>Wire</tt> objects. |
| * A bundle registering a Producer service or a Consumer service |
| * must have the appropriate <tt>ServicePermission[REGISTER,Consumer|Producer]</tt> to register the service and |
| * will be passed <tt>Wire</tt> objects when the service object's |
| * <tt>consumersConnected</tt> or <tt>producersConnected</tt> method is called. |
| * |
| * <p>Scope. Each Wire object can have a scope set with the <tt>setScope</tt> method. This |
| * method should be called by a Consumer service when it assumes a Producer service that is |
| * composite (supports multiple information items). The names in the scope must be |
| * verified by the <tt>Wire</tt> object before it is used in communication. The semantics of the |
| * names depend on the Producer service and must not be interpreted by the Wire Admin service. |
| * |
| * @author <a href="mailto:dev@felix.apache.org">Felix Project Team</a> * |
| */ |
| public class WireImpl implements Wire, java.io.Serializable |
| { |
| static final long serialVersionUID = -3637966367104019136L; |
| |
| // Persistent attributes |
| |
| // p. 327 "The Wire admin object contains a Persistend Identity (PID) for |
| // a consumer service and a PID for a producer service" These properties |
| // are also contained in the dictionary, but they are stored to optimize |
| // access. |
| private String m_producerPID; |
| private String m_consumerPID; |
| |
| private Dictionary m_properties; |
| |
| // Transient attributes |
| |
| transient private boolean m_isValid = true; |
| transient private boolean m_isConnected = false; |
| transient private Filter m_filter = null; |
| |
| transient private ServiceReference m_producerServiceRef; |
| transient private Producer m_producer; |
| transient private boolean m_producerIsComposite = false; |
| transient private String [] m_producerScope = null; |
| |
| transient private ServiceReference m_consumerServiceRef; |
| transient private Consumer m_consumer; |
| transient private boolean m_consumerIsComposite = false; |
| transient private String [] m_consumerScope = null; |
| |
| transient private BundleContext m_bundleContext; |
| transient private EventManager m_eventManager; |
| transient private Object m_lastValue; |
| transient private String[] m_scope; |
| |
| transient private long m_lastUpdate; |
| transient private boolean m_isFirstUpdate; |
| transient FilterDictionary m_dictionary; |
| |
| /** |
| * Constructor with package visibility |
| * |
| * @param producerPID |
| * @param consumerPID |
| * @param properties |
| */ |
| WireImpl(String producerPID, String consumerPID, Dictionary properties) |
| { |
| m_producerPID = producerPID; |
| m_consumerPID = consumerPID; |
| m_properties = properties; |
| |
| // set the scope which is the intersection of strings in the WIREADMIN_PRODUCER_SCOPE properties and the strings in the WIREADMIN_CONSUMER_SCOPE |
| m_scope = null; |
| } |
| |
| /** |
| * Method called after construction and after deserialization |
| * |
| * @param ctxt |
| * @param eventManager |
| */ |
| void initialize(BundleContext ctxt, EventManager eventManager) |
| { |
| m_isValid = true; |
| m_isConnected = false; |
| |
| m_bundleContext = ctxt; |
| m_eventManager = eventManager; |
| |
| m_lastValue = null; |
| |
| m_lastUpdate = 0; |
| |
| m_isFirstUpdate = true; |
| |
| /* |
| if(m_date == null) |
| { |
| m_date = new Date(); |
| } |
| */ |
| m_dictionary = new FilterDictionary(); |
| } |
| |
| /** |
| * Return the state of this <tt>Wire</tt> object. |
| * |
| * <p>A connected <tt>Wire</tt> must always be disconnected before |
| * becoming invalid. |
| * |
| * @return <tt>false</tt> if this <tt>Wire</tt> object is invalid because it |
| * has been deleted via {@link WireAdmin#deleteWire}; |
| * <tt>true</tt> otherwise. |
| */ |
| public boolean isValid() |
| { |
| return m_isValid; |
| } |
| |
| /** |
| * Return the connection state of this <tt>Wire</tt> object. |
| * |
| * <p>A <tt>Wire</tt> is connected after the Wire Admin service receives |
| * notification that the Producer service and |
| * the Consumer service for this <tt>Wire</tt> object are both registered. |
| * This method will return <tt>true</tt> prior to notifying the Producer |
| * and Consumer services via calls |
| * to their respective <tt>consumersConnected</tt> and <tt>producersConnected</tt> |
| * methods. |
| * <p>A <tt>WireAdminEvent</tt> of type {@link WireAdminEvent#WIRE_CONNECTED} |
| * must be broadcast by the Wire Admin service when |
| * the <tt>Wire</tt> becomes connected. |
| * |
| * <p>A <tt>Wire</tt> object |
| * is disconnected when either the Consumer or Producer |
| * service is unregistered or the <tt>Wire</tt> object is deleted. |
| * <p>A <tt>WireAdminEvent</tt> of type {@link WireAdminEvent#WIRE_DISCONNECTED} |
| * must be broadcast by the Wire Admin service when |
| * the <tt>Wire</tt> becomes disconnected. |
| * |
| * @return <tt>true</tt> if both the Producer and Consumer |
| * for this <tt>Wire</tt> object are connected to the <tt>Wire</tt> object; |
| * <tt>false</tt> otherwise. |
| */ |
| public boolean isConnected() |
| { |
| return m_isConnected; |
| } |
| |
| /** |
| * Return the list of data types understood by the |
| * Consumer service connected to this <tt>Wire</tt> object. Note that |
| * subclasses of the classes in this list are acceptable data types as well. |
| * |
| * <p>The list is the value of the {@link WireConstants#WIREADMIN_CONSUMER_FLAVORS} |
| * service property of the |
| * Consumer service object connected to this object. If no such |
| * property was registered or the type of the property value is not |
| * <tt>Class[]</tt>, this method must return <tt>null</tt>. |
| * |
| * @return An array containing the list of classes understood by the |
| * Consumer service or <tt>null</tt> if |
| * the <tt>Wire</tt> is not connected, |
| * or the consumer did not register a {@link WireConstants#WIREADMIN_CONSUMER_FLAVORS} property |
| * or the value of the property is not of type <tt>Class[]</tt>. |
| */ |
| |
| public Class[] getFlavors() |
| { |
| if(isConnected()) |
| { |
| try |
| { |
| return (Class [])m_consumerServiceRef.getProperty(WireConstants.WIREADMIN_CONSUMER_FLAVORS); |
| } |
| catch(ClassCastException ex) |
| { |
| return null; |
| } |
| } |
| else |
| { |
| return null; |
| |
| } |
| } |
| |
| /** |
| * Update the value. |
| * |
| * <p>This methods is called by the Producer service to |
| * notify the Consumer service connected to this <tt>Wire</tt> object |
| * of an updated value. |
| * <p>If the properties of this <tt>Wire</tt> object contain a |
| * {@link WireConstants#WIREADMIN_FILTER} property, |
| * then filtering is performed. |
| * If the Producer service connected to this <tt>Wire</tt> |
| * object was registered with the service |
| * property {@link WireConstants#WIREADMIN_PRODUCER_FILTERS}, the |
| * Producer service will perform the filtering according to the rules specified |
| * for the filter. Otherwise, this <tt>Wire</tt> object |
| * will perform the filtering of the value. |
| * <p>If no filtering is done, or the filter indicates the updated value should |
| * be delivered to the Consumer service, then |
| * this <tt>Wire</tt> object must call |
| * the {@link Consumer#updated} method with the updated value. |
| * If this <tt>Wire</tt> object is not connected, then the Consumer |
| * service must not be called and the value is ignored.<p> |
| * If the value is an <tt>Envelope</tt> object, and the scope name is not permitted, then the |
| * <tt>Wire</tt> object must ignore this call and not transfer the object to the Consumer |
| * service. |
| * |
| * <p>A <tt>WireAdminEvent</tt> of type {@link WireAdminEvent#WIRE_TRACE} |
| * must be broadcast by the Wire Admin service after |
| * the Consumer service has been successfully called. |
| * |
| * @param value The updated value. The value should be an instance of |
| * one of the types returned by {@link #getFlavors}. |
| * @see WireConstants#WIREADMIN_FILTER |
| */ |
| public void update(Object value) |
| { |
| // TODO Implement Access Control (p. 338) |
| if (isConnected()) |
| { |
| if(m_producerIsComposite == true) |
| { |
| // TODO Implement update for composite producers |
| WireAdminImpl.traceln("WireImpl.update: update for composite producers not yet implemented"); |
| return; |
| } |
| else // not a composite (Note: p. 341 "Filtering for composite producer services is not supported") |
| { |
| //long time = m_date.getTime(); |
| long time = new Date().getTime(); |
| |
| // We ignore filtering the first time... |
| if(m_isFirstUpdate == false && m_filter != null) |
| { |
| // If the Producer service was registered with the WIREADMIN_PRODUCER_FILTERS |
| // service property indicating that the Producer service will perform the data |
| // filtering then the Wire object will not perform data filtering. Otherwise, |
| // the Wire object must perform basic filtering. |
| try |
| { |
| m_dictionary.reset(value,time); |
| if(!m_filter.match(m_dictionary)) |
| { |
| WireAdminImpl.traceln("### Update rejected ("+m_properties.get(WireConstants.WIREADMIN_PID)+") filter evaluated to false:"+m_filter); |
| WireAdminImpl.traceln(" WIREVALUE_CURRENT.class"+m_dictionary.get(WireConstants.WIREVALUE_CURRENT).getClass().getName()); |
| WireAdminImpl.traceln(" WIREVALUE_CURRENT="+m_dictionary.get(WireConstants.WIREVALUE_CURRENT)); |
| WireAdminImpl.traceln(" WIREVALUE_PREVIOUS="+m_dictionary.get(WireConstants.WIREVALUE_PREVIOUS)); |
| WireAdminImpl.traceln(" WIREVALUE_DELTA_ABSOLUTE="+m_dictionary.get(WireConstants.WIREVALUE_DELTA_ABSOLUTE)); |
| WireAdminImpl.traceln(" WIREVALUE_DELTA_RELATIVE="+m_dictionary.get(WireConstants.WIREVALUE_DELTA_RELATIVE)); |
| WireAdminImpl.traceln(" WIREVALUE_ELAPSED="+m_dictionary.get(WireConstants.WIREVALUE_ELAPSED)); |
| return; |
| } |
| } |
| catch(Exception ex) |
| { |
| // Could happen... |
| WireAdminImpl.trace(ex); |
| } |
| |
| } |
| try |
| { |
| m_consumer.updated(this, value); |
| if(m_isFirstUpdate == true) |
| { |
| m_isFirstUpdate = false; |
| } |
| m_lastUpdate = time; |
| m_lastValue = value; |
| // Fire event |
| m_eventManager.fireEvent(WireAdminEvent.WIRE_TRACE,this); |
| } |
| catch(Exception ex) |
| { |
| m_eventManager.fireEvent(WireAdminEvent.CONSUMER_EXCEPTION,this,ex); |
| } |
| } |
| } |
| } |
| |
| /** |
| * Poll for an updated value. |
| * |
| * <p>This methods is normally called by the Consumer service to |
| * request an updated value from the Producer service |
| * connected to this <tt>Wire</tt> object. |
| * This <tt>Wire</tt> object will call |
| * the {@link Producer#polled} method to obtain an updated value. |
| * If this <tt>Wire</tt> object is not connected, then the Producer |
| * service must not be called.<p> |
| * |
| * If this <tt>Wire</tt> object has a scope, then this method |
| * must return an array of <tt>Envelope</tt> objects. The objects returned must |
| * match the scope of this object. The <tt>Wire</tt> object must remove |
| * all <tt>Envelope</tt> objects with a scope name that is not in the <tt>Wire</tt> object's scope. |
| * Thus, the list of objects returned |
| * must only contain <tt>Envelope</tt> objects with a permitted scope name. If the |
| * array becomes empty, <tt>null</tt> must be returned. |
| * |
| * <p>A <tt>WireAdminEvent</tt> of type {@link WireAdminEvent#WIRE_TRACE} |
| * must be broadcast by the Wire Admin service after |
| * the Producer service has been successfully called. |
| * |
| * @return A value whose type should be one of the types |
| * returned by {@link #getFlavors}, <tt>Envelope[]</tt>, or <tt>null</tt> if |
| * the <tt>Wire</tt> object is not connected, |
| * the Producer service threw an exception, or |
| * the Producer service returned a value which is not an instance of |
| * one of the types returned by {@link #getFlavors}. |
| */ |
| public Object poll() { |
| // p.330 "Update filtering must not apply to polling" |
| if (isConnected()) |
| { |
| try |
| { |
| Object value = m_producer.polled(this); |
| Class []flavors = getFlavors(); |
| |
| boolean valueOk = false; |
| |
| // Test if the value is ok with respect to the flavors understood by |
| // the consumer |
| for(int i=0; i<flavors.length; i++) |
| { |
| Class currentClass = flavors[i]; |
| if(currentClass.isInstance(value)) |
| { |
| valueOk = true; |
| } |
| } |
| if(valueOk) |
| { |
| m_eventManager.fireEvent(WireAdminEvent.WIRE_TRACE,this); |
| m_lastValue = value; |
| return m_lastValue; |
| } |
| else |
| { |
| WireAdminImpl.traceln("WireImpl.poll: value returned by producer is not undestood by consumer"); |
| return null; |
| } |
| } |
| catch(Exception ex) |
| { |
| m_eventManager.fireEvent(WireAdminEvent.PRODUCER_EXCEPTION,this,ex); |
| return null; |
| } |
| } |
| else |
| { |
| // p. 333 "If the poll() method on the wire object is called and the |
| // producer is unregistered it must return a null value" |
| return null; |
| } |
| } |
| |
| /** |
| * Return the last value sent through this <tt>Wire</tt> object. |
| * |
| * <p>The returned value is the most recent, valid value passed to the |
| * {@link #update} method or returned by the {@link #poll} method |
| * of this object. If filtering is performed by this <tt>Wire</tt> object, |
| * this methods returns the last value provided by the Producer service. This |
| * value may be an <tt>Envelope[]</tt> when the Producer service |
| * uses scoping. If the return value is an Envelope object (or array), it |
| * must be verified that the Consumer service has the proper WirePermission to see it. |
| * |
| * @return The last value passed though this <tt>Wire</tt> object |
| * or <tt>null</tt> if no valid values have been passed or the Consumer service has no permission. |
| */ |
| public Object getLastValue() |
| { |
| return m_lastValue; |
| } |
| |
| /** |
| * Return the wire properties for this <tt>Wire</tt> object. |
| * |
| * @return The properties for this <tt>Wire</tt> object. |
| * The returned <tt>Dictionary</tt> must be read only. |
| */ |
| public Dictionary getProperties() |
| { |
| return m_properties; |
| } |
| |
| /** |
| * Return the calculated scope of this <tt>Wire</tt> object. |
| * |
| * The purpose of the <tt>Wire</tt> object's scope is to allow a Producer |
| * and/or Consumer service to produce/consume different types |
| * over a single <tt>Wire</tt> object (this was deemed necessary for efficiency |
| * reasons). Both the Consumer service and the |
| * Producer service must set an array of scope names (their scope) with |
| * the service registration property <tt>WIREADMIN_PRODUCER_SCOPE</tt>, or <tt>WIREADMIN_CONSUMER_SCOPE</tt> when they can |
| * produce multiple types. If a Producer service can produce different types, it should set this property |
| * to the array of scope names it can produce, the Consumer service |
| * must set the array of scope names it can consume. The scope of a <tt>Wire</tt> |
| * object is defined as the intersection of permitted scope names of the |
| * Producer service and Consumer service. |
| * <p>If neither the Consumer, or the Producer service registers scope names with its |
| * service registration, then the <tt>Wire</tt> object's scope must be <tt>null</tt>. |
| * <p>The <tt>Wire</tt> object's scope must not change when a Producer or Consumer services |
| * modifies its scope. |
| * <p>A scope name is permitted for a Producer service when the registering bundle has |
| * <tt>WirePermission[PRODUCE]</tt>, and for a Consumer service when |
| * the registering bundle has <tt>WirePermission[CONSUME]</tt>.<p> |
| * If either Consumer service or Producer service has not set a <tt>WIREADMIN_*_SCOPE</tt> property, then |
| * the returned value must be <tt>null</tt>.<p> |
| * If the scope is set, the <tt>Wire</tt> object must enforce the scope names when <tt>Envelope</tt> objects are |
| * used as a parameter to update or returned from the <tt>poll</tt> method. The <tt>Wire</tt> object must then |
| * remove all <tt>Envelope</tt> objects with a scope name that is not permitted. |
| * |
| * @return A list of permitted scope names or null if the Produce or Consumer service has set no scope names. |
| */ |
| public String[] getScope() |
| { |
| return m_scope; |
| } |
| |
| /** |
| * Return true if the given name is in this <tt>Wire</tt> object's scope. |
| * |
| * @param name The scope name |
| * @return true if the name is listed in the permitted scope names |
| */ |
| public boolean hasScope(String name) |
| { |
| if (m_scope != null) |
| { |
| for (int i = 0; i < m_scope.length; i++) |
| { |
| if (name.equals(m_scope[i])) |
| { |
| return true; |
| } |
| } |
| } |
| return false; |
| } |
| |
| /** |
| * @see java.lang.Object#toString() |
| */ |
| public String toString() |
| { |
| return super.toString() |
| + ":[" |
| + getProperties().get(WireConstants.WIREADMIN_PID) |
| + "," |
| + getProperties().get(WireConstants.WIREADMIN_PRODUCER_PID) |
| + "," |
| + getProperties().get(WireConstants.WIREADMIN_CONSUMER_PID) |
| + "]"; |
| } |
| |
| /** |
| * Bind the consumer. |
| * |
| * @param consumer A <tt>ServiceReference</tt> corresponding to the consumer service |
| */ |
| void bindConsumer(ServiceReference consumerRef) |
| { |
| if(m_consumerServiceRef != null) |
| { |
| WireAdminImpl.traceln("WireImpl: consumer already bound!"); |
| return; |
| } |
| |
| // Pid must be present |
| if(consumerRef.getProperty(Constants.SERVICE_PID) == null) |
| { |
| WireAdminImpl.traceln("WireImpl: Consumer service has no PID "+consumerRef); |
| return; |
| } |
| |
| // Flavors must be present |
| if(consumerRef.getProperty(WireConstants.WIREADMIN_CONSUMER_FLAVORS) == null) |
| { |
| WireAdminImpl.traceln("WireImpl: Consumer service has no WIREADMIN_CONSUMER_FLAVORS "+consumerRef); |
| return; |
| } |
| |
| // Is this a composite? |
| if(consumerRef.getProperty(WireConstants.WIREADMIN_CONSUMER_COMPOSITE) != null) |
| { |
| m_consumerIsComposite = true; |
| m_consumerScope = (String []) consumerRef.getProperty(WireConstants.WIREADMIN_CONSUMER_SCOPE); |
| |
| } |
| |
| m_consumerServiceRef = consumerRef; |
| m_consumer = (Consumer) m_bundleContext.getService(consumerRef); |
| |
| if(m_producer != null) |
| { |
| if(m_producerIsComposite) |
| { |
| if(matchComposites() == false) |
| { |
| WireAdminImpl.traceln("WireImpl.bindConsumer : warning composite identities do not match"); |
| } |
| } |
| m_isConnected = true; |
| m_eventManager.fireEvent(WireAdminEvent.WIRE_CONNECTED,this); |
| } |
| } |
| |
| /** |
| * Unbind the consumer |
| * |
| */ |
| void unbindConsumer() |
| { |
| // This test is made because knopflerfish doesn't support ungetService(null); |
| if(m_consumerServiceRef != null) |
| { |
| m_bundleContext.ungetService(m_consumerServiceRef); |
| if(m_isConnected) |
| { |
| m_isConnected = false; |
| m_eventManager.fireEvent(WireAdminEvent.WIRE_DISCONNECTED,this); |
| } |
| m_consumer = null; |
| m_consumerServiceRef = null; |
| } |
| } |
| |
| /** |
| * Bind the producer |
| * |
| * @param producer A <tt>ServiceReference</tt> corresponding to the producer service |
| */ |
| void bindProducer(ServiceReference producerRef) |
| { |
| if(m_producerServiceRef != null) |
| { |
| WireAdminImpl.traceln("WireImpl: producer already bound!"); |
| return; |
| } |
| |
| // Pid must be present |
| if(producerRef.getProperty(Constants.SERVICE_PID) == null) |
| { |
| WireAdminImpl.traceln("WireImpl.bindProducer: Producer service has no PID "+producerRef); |
| return; |
| } |
| |
| // Flavors must be present |
| if(producerRef.getProperty(WireConstants.WIREADMIN_PRODUCER_FLAVORS) == null) |
| { |
| WireAdminImpl.traceln("WireImpl: Consumer service has no WIREADMIN_PRODUCER_FLAVORS "+producerRef); |
| return; |
| } |
| |
| // Is this a composite? |
| if(producerRef.getProperty(WireConstants.WIREADMIN_PRODUCER_COMPOSITE) != null) |
| { |
| m_producerIsComposite = true; |
| m_producerScope = (String []) producerRef.getProperty(WireConstants.WIREADMIN_PRODUCER_SCOPE); |
| } |
| |
| m_producerServiceRef = producerRef; |
| m_producer = (Producer) m_bundleContext.getService(producerRef); |
| |
| // p. 329 " If this property (wireadmin.producer.filters) is not set, |
| // the Wire object must filter according to the description in CompositeObjects" |
| if(producerRef.getProperty(WireConstants.WIREADMIN_PRODUCER_FILTERS) == null) |
| { |
| String filter = (String) m_properties.get(WireConstants.WIREADMIN_FILTER); |
| if(filter != null) |
| { |
| try |
| { |
| m_filter = m_bundleContext.createFilter(filter); |
| } |
| catch(InvalidSyntaxException ex) |
| { |
| WireAdminImpl.traceln("WireImpl.bindProducer: Ignoring filter with invalid syntax "+filter); |
| } |
| } |
| } |
| |
| if(m_consumer != null) |
| { |
| if(m_consumerIsComposite) |
| { |
| if(matchComposites() == false) |
| { |
| WireAdminImpl.traceln("WireImpl.bindProducer : warning composite identities do not match"); |
| } |
| } |
| m_isConnected = true; |
| // fire the corresponding event |
| m_eventManager.fireEvent(WireAdminEvent.WIRE_CONNECTED,this); |
| } |
| } |
| |
| /** |
| * Unbind the producer |
| * |
| */ |
| void unbindProducer() |
| { |
| if(m_producerServiceRef != null) |
| { |
| m_bundleContext.ungetService(m_producerServiceRef); |
| if(m_isConnected) |
| { |
| m_isConnected = false; |
| // fire the corresponding event |
| m_eventManager.fireEvent(WireAdminEvent.WIRE_DISCONNECTED,this); |
| } |
| m_producer = null; |
| m_producerServiceRef = null; |
| } |
| } |
| |
| /** |
| * Check if composites match. Match occurs when "at least one equal composite identity is |
| * listed on both the Producer and Consmer composite identity service property" (p. 336) |
| * |
| * @return <tt>true</tt> if they match, <tt>false</tt>otherwise |
| */ |
| private boolean matchComposites() |
| { |
| String [] producerIdentities = (String []) m_producerServiceRef.getProperty(WireConstants.WIREADMIN_PRODUCER_COMPOSITE); |
| String [] consumerIdentities = (String []) m_producerServiceRef.getProperty(WireConstants.WIREADMIN_PRODUCER_COMPOSITE); |
| |
| boolean match = false; |
| |
| // confirm matching |
| |
| for(int i = 0; i< producerIdentities.length; i++) |
| { |
| String currentProducerIdentity = producerIdentities [i]; |
| for(int j = 0; j < consumerIdentities.length; j++) |
| { |
| String currentConsumerIdentity = consumerIdentities [j]; |
| if (currentProducerIdentity.equals(currentConsumerIdentity)) |
| { |
| match = true; |
| break; |
| } |
| } |
| } |
| |
| // setup wire scope |
| |
| if (m_consumerScope != null && m_producerScope != null) |
| { |
| // p. 337 "It is allowed to register with a wildcard, indicating that all scopenames |
| // are supported. In that case, the WIREADMIN_SCOPE_ALL ({"*"}) should be registered as the |
| // scope of the serivce. The WireObject's scope is then fully defined by the |
| // other service connected to the wire object |
| if(m_consumerScope.length == 1 && m_consumerScope[0].equals("*")) |
| { |
| m_scope = m_producerScope; |
| } |
| else if(m_producerScope.length == 1 && m_producerScope[0].equals("*")) |
| { |
| m_scope = m_consumerScope; |
| } |
| else |
| { |
| /* |
| // TODO Implement wire scope creation based on producer, consumer and wire permissions (p. 338) |
| |
| ServiceReference ref = m_bundleContext.getServiceReference(PermissionAdmin.class.getName()); |
| if(ref != null) |
| { |
| PermissionAdmin permAdmin = (PermissionAdmin) m_bundleContext.getService(ref); |
| PermissionInfo [] producerPermissions = permAdmin.getPermissions(m_producerServiceRef.getBundle().getLocation()); |
| PermissionInfo [] consumerPermissions = permAdmin.getPermissions(m_consumerServiceRef.getBundle().getLocation()); |
| } |
| */ |
| } |
| } |
| else |
| { |
| // p. 337 "Not registering this property (WIREADMIN_CONSUMER_SCOPE or WIREADMIN_PRODUCER_SCOPE) |
| // by the Consumer or the Producer service indicates to the WireAdmin service that any |
| // Wire object connected to that service must return null for the Wire.getScope() method" |
| m_scope = null; |
| } |
| |
| return match; |
| } |
| |
| /** |
| * Called to invalidate the wire |
| * |
| */ |
| void invalidate() |
| { |
| if(m_isValid) |
| { |
| unbindProducer(); |
| unbindConsumer(); |
| m_isValid=false; |
| } |
| } |
| |
| /** |
| * Update the properties |
| * |
| * @param properties new properties |
| */ |
| void updateProperties(Dictionary properties) |
| { |
| m_properties = properties; |
| } |
| |
| /** |
| * Return the service reference corresponding to the producer |
| * |
| * @return a <tt>ServiceReference</tt> corresponding to the producer |
| */ |
| ServiceReference getProducerServiceRef() |
| { |
| return m_producerServiceRef; |
| } |
| |
| /** |
| * Return the producer service object |
| * |
| * @return An <tt>Object</tt> corresponding to the producer |
| */ |
| Producer getProducer() |
| { |
| return m_producer; |
| } |
| |
| /** |
| * return the producer PID |
| * |
| * @return |
| */ |
| String getProducerPID() |
| { |
| return m_producerPID; |
| } |
| |
| /** |
| * Return the service reference corresponding to the consumer |
| * |
| * @return a <tt>ServiceReference</tt> corresponding to the consumer |
| */ |
| ServiceReference getConsumerServiceRef() |
| { |
| return m_consumerServiceRef; |
| } |
| |
| /** |
| * Returns the consumer service object |
| * |
| * @return An <tt>Object</tt> corresponding to the consumer |
| */ |
| Consumer getConsumer() |
| { |
| return m_consumer; |
| } |
| |
| /** |
| * return the consumer PID |
| * |
| * @return |
| */ |
| String getConsumerPID() |
| { |
| return m_consumerPID; |
| } |
| |
| /** |
| * This inner class implements a dictionary that is used to filter out values |
| * during calls to update. This design choice was favored to avoid constructing |
| * a new dictionary for every call to update and to avoid doing unnecessary |
| * calculations. |
| */ |
| class FilterDictionary extends Dictionary |
| { |
| private Object m_value; |
| private long m_time; |
| |
| /** |
| * Must be called prior to evaluating the filter |
| * |
| * @param value |
| * @param time |
| */ |
| void reset(Object value, long time) |
| { |
| m_value = value; |
| m_time = time; |
| } |
| |
| /** |
| * |
| */ |
| public Object get(Object key) |
| { |
| if(key.equals(WireConstants.WIREVALUE_CURRENT)) |
| { |
| return m_value; |
| } |
| else if(key.equals(WireConstants.WIREVALUE_PREVIOUS)) |
| { |
| return m_lastValue; |
| } |
| else if(m_value instanceof Number && key.equals(WireConstants.WIREVALUE_DELTA_ABSOLUTE)) |
| { |
| return null; |
| } |
| else if(m_value instanceof Number && key.equals(WireConstants.WIREVALUE_DELTA_RELATIVE)) |
| { |
| return null; |
| } |
| else if(key.equals(WireConstants.WIREVALUE_ELAPSED)) |
| { |
| if(m_lastUpdate == 0) |
| { |
| return new Long(0); |
| } |
| else |
| { |
| long delay = m_time - m_lastUpdate; |
| //System.out.println("### delay = "+(delay)); |
| return new Long(delay); |
| } |
| } |
| else |
| { |
| WireAdminImpl.traceln("### key not found:"+key); |
| return null; |
| } |
| } |
| |
| /** |
| * Never empty |
| */ |
| public boolean isEmpty() |
| { |
| return false; |
| } |
| |
| /** |
| * Remove not supported |
| */ |
| public Object remove(Object obj) |
| { |
| return null; |
| } |
| |
| /** |
| * Size is static |
| */ |
| public int size() |
| { |
| return 5; |
| } |
| |
| /** |
| * Put not supported |
| */ |
| public Object put(Object key, Object value) |
| { |
| return null; |
| } |
| |
| /** |
| * |
| */ |
| public Enumeration keys() |
| { |
| Vector keys=new Vector(); |
| |
| keys.addElement(WireConstants.WIREVALUE_ELAPSED); |
| keys.addElement(WireConstants.WIREVALUE_CURRENT); |
| keys.addElement(WireConstants.WIREVALUE_PREVIOUS); |
| keys.addElement(WireConstants.WIREVALUE_DELTA_ABSOLUTE); |
| keys.addElement(WireConstants.WIREVALUE_DELTA_RELATIVE); |
| |
| return keys.elements(); |
| } |
| |
| /** |
| * Not supported |
| */ |
| public Enumeration elements() |
| { |
| return null; |
| } |
| } |
| } |
