2 * Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved.
4 * This program and the accompanying materials are made available under the
5 * terms of the Eclipse Public License v1.0 which accompanies this distribution,
6 * and is available at http://www.eclipse.org/legal/epl-v10.html
8 package org.opendaylight.controller.config.manager.impl;
10 import com.google.common.base.Preconditions;
11 import com.google.common.collect.ImmutableMap;
12 import com.google.common.collect.ImmutableSet;
13 import java.util.AbstractMap.SimpleImmutableEntry;
14 import java.util.Collections;
15 import java.util.HashMap;
16 import java.util.HashSet;
18 import java.util.Map.Entry;
20 import javax.management.InstanceAlreadyExistsException;
21 import javax.management.InstanceNotFoundException;
22 import javax.management.ObjectName;
23 import org.opendaylight.controller.config.api.LookupRegistry;
24 import org.opendaylight.controller.config.api.ModuleIdentifier;
25 import org.opendaylight.controller.config.api.ServiceReferenceReadableRegistry;
26 import org.opendaylight.controller.config.api.ServiceReferenceWritableRegistry;
27 import org.opendaylight.controller.config.api.annotations.ServiceInterfaceAnnotation;
28 import org.opendaylight.controller.config.api.jmx.ObjectNameUtil;
29 import org.opendaylight.controller.config.manager.impl.jmx.BaseJMXRegistrator;
30 import org.opendaylight.controller.config.manager.impl.jmx.ServiceReference;
31 import org.opendaylight.controller.config.manager.impl.jmx.ServiceReferenceMXBeanImpl;
32 import org.opendaylight.controller.config.manager.impl.jmx.ServiceReferenceRegistrator;
33 import org.opendaylight.controller.config.manager.impl.jmx.ServiceReferenceRegistrator.ServiceReferenceJMXRegistration;
34 import org.opendaylight.controller.config.manager.impl.jmx.ServiceReferenceRegistrator.ServiceReferenceTransactionRegistratorFactory;
35 import org.opendaylight.controller.config.manager.impl.jmx.ServiceReferenceRegistrator.ServiceReferenceTransactionRegistratorFactoryImpl;
36 import org.opendaylight.controller.config.manager.impl.util.InterfacesHelper;
37 import org.opendaylight.controller.config.spi.ModuleFactory;
38 import org.osgi.framework.BundleContext;
39 import org.slf4j.Logger;
40 import org.slf4j.LoggerFactory;
42 public class ServiceReferenceRegistryImpl implements CloseableServiceReferenceReadableRegistry, SearchableServiceReferenceWritableRegistry {
43 private static final Logger LOG = LoggerFactory.getLogger(ServiceReferenceRegistryImpl.class);
45 private final Map<String, ModuleFactory> factories;
46 private final Map<String, Set<String>> factoryNamesToQNames;
47 // validator of incoming ObjectNames - throws InstanceNotFoundException if not found either in registry or transaction
48 private final LookupRegistry lookupRegistry;
49 private final ServiceReferenceRegistrator serviceReferenceRegistrator;
50 // helper method for getting QName of SI from namespace + local name
51 private final Map<String /* namespace */, Map<String /* local name */, ServiceInterfaceAnnotation>> namespacesToAnnotations;
52 private final Map<String /* service qName */, ServiceInterfaceAnnotation> serviceQNamesToAnnotations;
53 // all Service Interface qNames for sanity checking
54 private final Set<String /* qName */> allQNames;
55 Map<ModuleIdentifier, Map<ServiceInterfaceAnnotation, String /* service ref name */>> modulesToServiceRef = new HashMap<>();
58 // actual reference database
59 private final Map<ServiceReference, ModuleIdentifier> refNames = new HashMap<>();
60 private final boolean writable;
61 private final Map<ServiceReference, Entry<ServiceReferenceMXBeanImpl, ServiceReferenceJMXRegistration>> mBeans = new HashMap<>();
63 private ServiceReferenceRegistryImpl(final Map<String, ModuleFactory> factories, final LookupRegistry lookupRegistry,
64 final ServiceReferenceTransactionRegistratorFactory serviceReferenceRegistratorFactory, final boolean writable) {
65 this.factories = factories;
66 this.writable = writable;
67 this.lookupRegistry = lookupRegistry;
69 this.serviceReferenceRegistrator = serviceReferenceRegistratorFactory.create();
71 Map<String, Set<String /* QName */>> modifiableFactoryNamesToQNames = new HashMap<>();
72 Set<ServiceInterfaceAnnotation> allAnnotations = new HashSet<>();
73 Set<String /* qName */> allQNameSet = new HashSet<>();
75 for (Entry<String, ModuleFactory> entry : factories.entrySet()) {
76 if (!entry.getKey().equals(entry.getValue().getImplementationName())) {
77 LOG.error("Possible error in code: Mismatch between supplied and actual name of {}", entry);
78 throw new IllegalArgumentException("Possible error in code: Mismatch between supplied and actual name of " + entry);
80 Set<ServiceInterfaceAnnotation> siAnnotations = InterfacesHelper.getServiceInterfaceAnnotations(entry.getValue());
81 Set<String> qNames = InterfacesHelper.getQNames(siAnnotations);
82 allAnnotations.addAll(siAnnotations);
83 allQNameSet.addAll(qNames);
84 modifiableFactoryNamesToQNames.put(entry.getKey(), qNames);
86 this.factoryNamesToQNames = ImmutableMap.copyOf(modifiableFactoryNamesToQNames);
87 this.allQNames = ImmutableSet.copyOf(allQNameSet);
88 // fill namespacesToAnnotations
89 Map<String /* namespace */, Map<String /* localName */, ServiceInterfaceAnnotation>> modifiableNamespacesToAnnotations = new HashMap<>();
90 Map<String /* service qName*/, ServiceInterfaceAnnotation> modifiableServiceQNamesToAnnotations = new HashMap<>();
91 for (ServiceInterfaceAnnotation sia : allAnnotations) {
92 Map<String, ServiceInterfaceAnnotation> ofNamespace =
93 modifiableNamespacesToAnnotations.computeIfAbsent(sia.namespace(), k -> new HashMap<>());
94 if (ofNamespace.containsKey(sia.localName())) {
96 "Cannot construct namespacesToAnnotations map, conflict between local names in {}, offending local name: {}, map so far {}",
97 sia.namespace(), sia.localName(), modifiableNamespacesToAnnotations);
98 throw new IllegalArgumentException("Conflict between local names in " + sia.namespace() + " : " + sia.localName());
100 ofNamespace.put(sia.localName(), sia);
101 modifiableServiceQNamesToAnnotations.put(sia.value(), sia);
103 this.namespacesToAnnotations = ImmutableMap.copyOf(modifiableNamespacesToAnnotations);
104 this.serviceQNamesToAnnotations = ImmutableMap.copyOf(modifiableServiceQNamesToAnnotations);
105 LOG.trace("factoryNamesToQNames:{}", this.factoryNamesToQNames);
109 * Static constructor for config registry. Since only transaction can write to this registry, it will
110 * return blank state.
112 public static CloseableServiceReferenceReadableRegistry createInitialSRLookupRegistry() {
113 // since this is initial state, just throw exception:
114 LookupRegistry lookupRegistry = new LookupRegistry() {
116 public Set<ObjectName> lookupConfigBeans() {
117 throw new UnsupportedOperationException();
121 public Set<ObjectName> lookupConfigBeans(final String moduleName) {
122 throw new UnsupportedOperationException();
126 public Set<ObjectName> lookupConfigBeans(final String moduleName, final String instanceName) {
127 throw new UnsupportedOperationException();
131 public ObjectName lookupConfigBean(final String moduleName, final String instanceName) throws InstanceNotFoundException {
132 throw new UnsupportedOperationException();
136 public void checkConfigBeanExists(final ObjectName objectName) throws InstanceNotFoundException {
137 throw new InstanceNotFoundException("Cannot find " + objectName + " - Tried to use mocking registry");
141 public Set<String> getAvailableModuleFactoryQNames() {
142 throw new UnsupportedOperationException();
146 public Set<ObjectName> lookupRuntimeBeans() {
147 throw new UnsupportedOperationException();
151 public Set<ObjectName> lookupRuntimeBeans(final String moduleName, final String instanceName) {
152 throw new UnsupportedOperationException();
156 public String toString() {
160 ServiceReferenceTransactionRegistratorFactory serviceReferenceRegistratorFactory = () -> new ServiceReferenceRegistrator() {
162 public String getNullableTransactionName() {
163 throw new UnsupportedOperationException();
167 public ServiceReferenceJMXRegistration registerMBean(final ServiceReferenceMXBeanImpl object, final ObjectName on) throws InstanceAlreadyExistsException {
168 throw new UnsupportedOperationException();
172 public void close() {
176 return new ServiceReferenceRegistryImpl(Collections.<String, ModuleFactory>emptyMap(), lookupRegistry,
177 serviceReferenceRegistratorFactory, false);
181 * Static constructor for transaction controller. Take current state as seen by config registry, allow writing new data.
183 public static SearchableServiceReferenceWritableRegistry createSRWritableRegistry(final ServiceReferenceReadableRegistry oldReadableRegistry,
184 final ConfigTransactionLookupRegistry txLookupRegistry,
185 final Map<String, Map.Entry<ModuleFactory, BundleContext>> currentlyRegisteredFactories) {
187 if (txLookupRegistry == null) {
188 throw new IllegalArgumentException("txLookupRegistry is null");
190 ServiceReferenceRegistryImpl old = (ServiceReferenceRegistryImpl) oldReadableRegistry;
191 Map<String, ModuleFactory> factories = extractFactoriesMap(currentlyRegisteredFactories);
192 ServiceReferenceTransactionRegistratorFactory serviceReferenceRegistratorFactory = new ServiceReferenceTransactionRegistratorFactoryImpl(
193 txLookupRegistry.getTxModuleJMXRegistrator(), txLookupRegistry.getTxModuleJMXRegistrator().getTransactionName());
194 ServiceReferenceRegistryImpl newRegistry = new ServiceReferenceRegistryImpl(factories, txLookupRegistry,
195 serviceReferenceRegistratorFactory, true);
196 copy(old, newRegistry, txLookupRegistry.getTransactionIdentifier().getName());
201 * Copy back state to config registry after commit.
203 public static CloseableServiceReferenceReadableRegistry createSRReadableRegistry(final ServiceReferenceWritableRegistry oldWritableRegistry,
204 final LookupRegistry lookupRegistry, final BaseJMXRegistrator baseJMXRegistrator) {
205 ServiceReferenceRegistryImpl old = (ServiceReferenceRegistryImpl) oldWritableRegistry;
207 // even if factories do change, nothing in the mapping can change between transactions
208 ServiceReferenceTransactionRegistratorFactory serviceReferenceRegistratorFactory = new ServiceReferenceTransactionRegistratorFactoryImpl(baseJMXRegistrator);
209 ServiceReferenceRegistryImpl newRegistry = new ServiceReferenceRegistryImpl(old.factories, lookupRegistry,
210 serviceReferenceRegistratorFactory, false);
211 copy(old, newRegistry, null);
216 * Fill refNames and mBeans maps from old instance
218 private static void copy(final ServiceReferenceRegistryImpl old, final ServiceReferenceRegistryImpl newRegistry, final String nullableDstTransactionName) {
219 for (Entry<ServiceReference, Entry<ServiceReferenceMXBeanImpl, ServiceReferenceJMXRegistration>> refNameEntry : old.mBeans.entrySet()) {
220 ObjectName currentImplementation;
221 ObjectName currentImplementationSrc = refNameEntry.getValue().getKey().getCurrentImplementation();
222 if (nullableDstTransactionName != null) {
223 currentImplementation = ObjectNameUtil.withTransactionName(currentImplementationSrc, nullableDstTransactionName);
225 currentImplementation = ObjectNameUtil.withoutTransactionName(currentImplementationSrc);
228 boolean skipChecks = true;
229 newRegistry.saveServiceReference(refNameEntry.getKey(), currentImplementation, skipChecks);
230 } catch (final InstanceNotFoundException e) {
231 LOG.error("Cannot save service reference({}, {})", refNameEntry.getKey(), currentImplementation);
232 throw new IllegalStateException("Possible code error", e);
237 private static Map<String, ModuleFactory> extractFactoriesMap(final Map<String, Map.Entry<ModuleFactory, BundleContext>> currentlyRegisteredFactories) {
238 Map<String, ModuleFactory> result = new HashMap<>();
239 for (Entry<String, Entry<ModuleFactory, BundleContext>> entry : currentlyRegisteredFactories.entrySet()) {
240 result.put(entry.getKey(), entry.getValue().getKey());
246 public Map<ServiceInterfaceAnnotation, String /* service ref name */> findServiceInterfaces(final ModuleIdentifier moduleIdentifier) {
247 Map<ServiceInterfaceAnnotation, String /* service ref name */> result = modulesToServiceRef.get(moduleIdentifier);
248 if (result == null) {
249 return Collections.emptyMap();
251 return Collections.unmodifiableMap(result);
255 public synchronized Set<String> lookupServiceInterfaceNames(final ObjectName objectName) throws InstanceNotFoundException {
256 lookupRegistry.checkConfigBeanExists(objectName);
258 String factoryName = ObjectNameUtil.getFactoryName(objectName);
259 Set<String> serviceInterfaceAnnotations = factoryNamesToQNames.get(factoryName);
260 if (serviceInterfaceAnnotations == null) {
261 LOG.error("Possible error in code: cannot find factory annotations of '{}' extracted from ON {} in {}",
262 factoryName, objectName, factoryNamesToQNames);
263 throw new IllegalArgumentException("Cannot find factory with name " + factoryName);
265 return serviceInterfaceAnnotations;
269 public synchronized String getServiceInterfaceName(final String namespace, final String localName) {
270 Map<String /* localName */, ServiceInterfaceAnnotation> ofNamespace = namespacesToAnnotations.get(namespace);
271 if (ofNamespace == null) {
272 LOG.error("Cannot find namespace {} in {}", namespace, namespacesToAnnotations);
273 throw new IllegalArgumentException("Cannot find namespace " + namespace);
275 ServiceInterfaceAnnotation sia = ofNamespace.get(localName);
277 LOG.error("Cannot find local name {} in namespace {}, found only {}", localName, namespace, ofNamespace);
278 throw new IllegalArgumentException("Cannot find local name " + localName + " in namespace " + namespace);
286 public synchronized Map<String /* serviceInterfaceName */, Map<String/* refName */, ObjectName>> getServiceMapping() {
287 Map<String /* serviceInterfaceName */, Map<String/* refName */, ObjectName>> result = new HashMap<>();
288 for (Entry<ServiceReference, ModuleIdentifier> entry: refNames.entrySet()) {
289 String qName = entry.getKey().getServiceInterfaceQName();
290 Map<String /* refName */, ObjectName> innerMap = result.computeIfAbsent(qName, k -> new HashMap<>());
291 innerMap.put(entry.getKey().getRefName(), getObjectName(entry.getValue()));
296 private ObjectName getObjectName(final ModuleIdentifier moduleIdentifier) {
299 on = lookupRegistry.lookupConfigBean(moduleIdentifier.getFactoryName(), moduleIdentifier.getInstanceName());
300 } catch (final InstanceNotFoundException e) {
301 LOG.error("Cannot find instance {}", moduleIdentifier);
302 throw new IllegalStateException("Cannot find instance " + moduleIdentifier, e);
308 public synchronized ObjectName lookupConfigBeanByServiceInterfaceName(final String serviceInterfaceQName, final String refName) {
309 ServiceReference serviceReference = new ServiceReference(serviceInterfaceQName, refName);
310 ModuleIdentifier moduleIdentifier = refNames.get(serviceReference);
311 if (moduleIdentifier == null) {
312 LOG.error("Cannot find qname {} and refName {} in {}", serviceInterfaceQName, refName, refName);
313 throw new IllegalArgumentException("Cannot find " + serviceReference);
315 return getObjectName(moduleIdentifier);
319 public synchronized Map<String /* refName */, ObjectName> lookupServiceReferencesByServiceInterfaceName(final String serviceInterfaceQName) {
320 Map<String, Map<String, ObjectName>> serviceMapping = getServiceMapping();
321 Map<String, ObjectName> innerMap = serviceMapping.get(serviceInterfaceQName);
322 if (innerMap == null) {
323 LOG.error("Cannot find qname {} in {}", serviceInterfaceQName, refNames);
324 throw new IllegalArgumentException("Cannot find " + serviceInterfaceQName);
330 public synchronized ObjectName getServiceReference(final String serviceInterfaceQName, final String refName) throws InstanceNotFoundException {
331 ServiceReference serviceReference = new ServiceReference(serviceInterfaceQName, refName);
332 if (!mBeans.containsKey(serviceReference)) {
333 throw new InstanceNotFoundException("Cannot find " + serviceReference);
335 return getServiceON(serviceReference);
339 public synchronized void checkServiceReferenceExists(final ObjectName objectName) throws InstanceNotFoundException {
340 String actualTransactionName = ObjectNameUtil.getTransactionName(objectName);
341 String expectedTransactionName = serviceReferenceRegistrator.getNullableTransactionName();
342 if (writable && actualTransactionName == null || writable && !actualTransactionName.equals(expectedTransactionName)) {
343 throw new IllegalArgumentException("Mismatched transaction name in " + objectName);
345 String serviceQName = ObjectNameUtil.getServiceQName(objectName);
346 String referenceName = ObjectNameUtil.getReferenceName(objectName);
347 ServiceReference serviceReference = new ServiceReference(serviceQName, referenceName);
348 if (!refNames.containsKey(serviceReference)) {
349 LOG.warn("Cannot find {} in {}", serviceReference, refNames);
350 throw new InstanceNotFoundException("Service reference not found:" + objectName);
355 private void assertWritable() {
357 throw new IllegalStateException("Cannot write to readable registry");
362 public synchronized ObjectName saveServiceReference(final String serviceInterfaceName, final String refName, final ObjectName moduleON) throws InstanceNotFoundException {
364 ServiceReference serviceReference = new ServiceReference(serviceInterfaceName, refName);
365 return saveServiceReference(serviceReference, moduleON);
368 private synchronized ObjectName saveServiceReference(final ServiceReference serviceReference, final ObjectName moduleON)
369 throws InstanceNotFoundException{
370 return saveServiceReference(serviceReference, moduleON, false);
373 private synchronized ObjectName saveServiceReference(final ServiceReference serviceReference, final ObjectName moduleON,
374 final boolean skipChecks) throws InstanceNotFoundException {
376 // make sure it is found
378 lookupRegistry.checkConfigBeanExists(moduleON);
380 String factoryName = ObjectNameUtil.getFactoryName(moduleON);
381 String instanceName = ObjectNameUtil.getInstanceName(moduleON);
382 ModuleIdentifier moduleIdentifier = new ModuleIdentifier(factoryName, instanceName);
384 // check that service interface name exist
385 Set<String> serviceInterfaceQNames = factoryNamesToQNames.get(moduleIdentifier.getFactoryName());
386 if (serviceInterfaceQNames == null) {
387 LOG.error("Possible error in code: cannot find factoryName {} in {}, {}", moduleIdentifier.getFactoryName(),
388 factoryNamesToQNames, moduleIdentifier);
389 throw new IllegalStateException("Possible error in code: cannot find annotations of existing factory " + moduleIdentifier.getFactoryName());
391 // supplied serviceInterfaceName must exist in this collection
392 if (!serviceInterfaceQNames.contains(serviceReference.getServiceInterfaceQName())) {
393 LOG.error("Cannot find qName {} with factory name {}, found {}", serviceReference.getServiceInterfaceQName(), moduleIdentifier.getFactoryName(), serviceInterfaceQNames);
394 throw new IllegalArgumentException("Cannot find service interface " + serviceReference.getServiceInterfaceQName() + " within factory " + moduleIdentifier.getFactoryName());
398 // create service reference object name, put to mBeans
399 ObjectName result = getServiceON(serviceReference);
400 Entry<ServiceReferenceMXBeanImpl, ServiceReferenceJMXRegistration> mxBeanEntry = mBeans.get(serviceReference);
401 if (mxBeanEntry == null) {
402 // create dummy mx bean
403 ServiceReferenceMXBeanImpl dummyMXBean = new ServiceReferenceMXBeanImpl(moduleON);
404 ServiceReferenceJMXRegistration dummyMXBeanRegistration;
406 dummyMXBeanRegistration = serviceReferenceRegistrator.registerMBean(dummyMXBean, result);
407 } catch (final InstanceAlreadyExistsException e) {
408 throw new IllegalStateException("Possible error in code. Cannot register " + result, e);
410 mBeans.put(serviceReference, new SimpleImmutableEntry<>(dummyMXBean, dummyMXBeanRegistration));
413 mxBeanEntry.getKey().setCurrentImplementation(moduleON);
416 refNames.put(serviceReference, moduleIdentifier);
417 Map<ServiceInterfaceAnnotation, String /* service ref name */> refNamesToAnnotations =
418 modulesToServiceRef.computeIfAbsent(moduleIdentifier, k -> new HashMap<>());
420 ServiceInterfaceAnnotation annotation = serviceQNamesToAnnotations.get(serviceReference.getServiceInterfaceQName());
421 Preconditions.checkNotNull(annotation, "Possible error in code, cannot find annotation for " + serviceReference);
422 refNamesToAnnotations.put(annotation, serviceReference.getRefName());
426 private ObjectName getServiceON(final ServiceReference serviceReference) {
428 return ObjectNameUtil.createTransactionServiceON(serviceReferenceRegistrator.getNullableTransactionName(),
429 serviceReference.getServiceInterfaceQName(), serviceReference.getRefName());
432 return ObjectNameUtil.createReadOnlyServiceON(serviceReference.getServiceInterfaceQName(), serviceReference.getRefName());
436 public synchronized void removeServiceReference(final String serviceInterfaceName, final String refName) throws InstanceNotFoundException{
437 ServiceReference serviceReference = new ServiceReference(serviceInterfaceName, refName);
438 removeServiceReference(serviceReference);
441 private synchronized void removeServiceReference(final ServiceReference serviceReference) throws InstanceNotFoundException {
442 LOG.debug("Removing service reference {} from {}", serviceReference, this);
444 // is the qName known?
445 if (!allQNames.contains(serviceReference.getServiceInterfaceQName())) {
446 LOG.error("Cannot find qname {} in {}", serviceReference.getServiceInterfaceQName(), allQNames);
447 throw new IllegalArgumentException("Cannot find service interface " + serviceReference.getServiceInterfaceQName());
449 ModuleIdentifier removed = refNames.remove(serviceReference);
450 if (removed == null){
451 throw new InstanceNotFoundException("Cannot find " + serviceReference.getServiceInterfaceQName());
453 Entry<ServiceReferenceMXBeanImpl, ServiceReferenceJMXRegistration> entry = mBeans.remove(serviceReference);
455 throw new IllegalStateException("Possible code error: cannot remove from mBeans: " + serviceReference);
457 entry.getValue().close();
461 public synchronized void removeAllServiceReferences() {
463 for (ServiceReference serviceReference: mBeans.keySet()) {
465 removeServiceReference(serviceReference);
466 } catch (final InstanceNotFoundException e) {
467 throw new IllegalStateException("Possible error in code", e);
473 public synchronized boolean removeServiceReferences(final ObjectName moduleObjectName) throws InstanceNotFoundException {
474 lookupRegistry.checkConfigBeanExists(moduleObjectName);
475 String factoryName = ObjectNameUtil.getFactoryName(moduleObjectName);
476 // check that service interface name exist
477 Set<String> serviceInterfaceQNames = factoryNamesToQNames.get(factoryName);
478 return removeServiceReferences(moduleObjectName, serviceInterfaceQNames);
482 private boolean removeServiceReferences(final ObjectName moduleObjectName, final Set<String> qNames) throws InstanceNotFoundException {
483 ObjectNameUtil.checkType(moduleObjectName, ObjectNameUtil.TYPE_MODULE);
485 Set<ServiceReference> serviceReferencesLinkingTo = findServiceReferencesLinkingTo(moduleObjectName, qNames);
486 for (ServiceReference sr : serviceReferencesLinkingTo) {
487 removeServiceReference(sr);
489 return !serviceReferencesLinkingTo.isEmpty();
492 private Set<ServiceReference> findServiceReferencesLinkingTo(final ObjectName moduleObjectName, final Set<String> serviceInterfaceQNames) {
493 String factoryName = ObjectNameUtil.getFactoryName(moduleObjectName);
494 if (serviceInterfaceQNames == null) {
495 LOG.warn("Possible error in code: cannot find factoryName {} in {}, object name {}", factoryName, factoryNamesToQNames, moduleObjectName);
496 throw new IllegalStateException("Possible error in code: cannot find annotations of existing factory " + factoryName);
498 String instanceName = ObjectNameUtil.getInstanceName(moduleObjectName);
499 ModuleIdentifier moduleIdentifier = new ModuleIdentifier(factoryName, instanceName);
500 Set<ServiceReference> result = new HashSet<>();
501 for (Entry<ServiceReference, ModuleIdentifier> entry : refNames.entrySet()) {
502 if (entry.getValue().equals(moduleIdentifier)) {
503 result.add(entry.getKey());
510 public String toString() {
511 return "ServiceReferenceRegistryImpl{" +
512 "lookupRegistry=" + lookupRegistry +
513 "refNames=" + refNames +
514 ", factoryNamesToQNames=" + factoryNamesToQNames +
519 public void close() {
520 serviceReferenceRegistrator.close();