001    /**
002     * Copyright (c) 2000-present Liferay, Inc. All rights reserved.
003     *
004     * This library is free software; you can redistribute it and/or modify it under
005     * the terms of the GNU Lesser General Public License as published by the Free
006     * Software Foundation; either version 2.1 of the License, or (at your option)
007     * any later version.
008     *
009     * This library is distributed in the hope that it will be useful, but WITHOUT
010     * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
011     * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
012     * details.
013     */
014    
015    package com.liferay.portal.search.test;
016    
017    import com.liferay.portal.kernel.log.Log;
018    import com.liferay.portal.kernel.log.LogFactoryUtil;
019    import com.liferay.portal.kernel.search.Indexer;
020    import com.liferay.portal.kernel.search.IndexerRegistry;
021    import com.liferay.portal.kernel.search.dummy.DummyIndexer;
022    import com.liferay.registry.Registry;
023    import com.liferay.registry.RegistryUtil;
024    import com.liferay.registry.ServiceReference;
025    import com.liferay.registry.ServiceRegistration;
026    import com.liferay.registry.ServiceTracker;
027    import com.liferay.registry.ServiceTrackerCustomizer;
028    import com.liferay.registry.collections.StringServiceRegistrationMap;
029    import com.liferay.registry.collections.StringServiceRegistrationMapImpl;
030    
031    import java.util.HashSet;
032    import java.util.Map;
033    import java.util.Set;
034    import java.util.concurrent.ConcurrentHashMap;
035    
036    /**
037     * @author Michael C. Han
038     */
039    public class TestIndexerRegistry implements IndexerRegistry {
040    
041            public TestIndexerRegistry() {
042                    Registry registry = RegistryUtil.getRegistry();
043    
044                    _serviceTracker = registry.trackServices(
045                            (Class<Indexer<?>>)(Class<?>)Indexer.class,
046                            new IndexerServiceTrackerCustomizer());
047    
048                    _serviceTracker.open();
049            }
050    
051            public void destroy() {
052                    if (_serviceTracker != null) {
053                            _serviceTracker.close();
054                    }
055    
056                    _serviceTracker = null;
057            }
058    
059            @Override
060            public <T> Indexer<T> getIndexer(Class<T> clazz) {
061                    return getIndexer(clazz.getName());
062            }
063    
064            @Override
065            public <T> Indexer<T> getIndexer(String className) {
066                    return (Indexer<T>)_indexers.get(className);
067            }
068    
069            @Override
070            public Set<Indexer<?>> getIndexers() {
071                    return new HashSet<>(_indexers.values());
072            }
073    
074            @Override
075            public <T> Indexer<T> nullSafeGetIndexer(Class<T> clazz) {
076                    return nullSafeGetIndexer(clazz.getName());
077            }
078    
079            @Override
080            public <T> Indexer<T> nullSafeGetIndexer(String className) {
081                    Indexer<T> indexer = getIndexer(className);
082    
083                    if (indexer != null) {
084                            return indexer;
085                    }
086    
087                    if (_log.isInfoEnabled()) {
088                            _log.info("No indexer found for " + className);
089                    }
090    
091                    return (Indexer<T>)_dummyIndexer;
092            }
093    
094            @Override
095            public void register(Indexer<?> indexer) {
096                    Registry registry = RegistryUtil.getRegistry();
097    
098                    ServiceRegistration<Indexer<?>> serviceRegistration =
099                            registry.registerService(
100                                    (Class<Indexer<?>>)(Class<?>)Indexer.class, indexer);
101    
102                    _serviceRegistrations.put(indexer.getClassName(), serviceRegistration);
103            }
104    
105            @Override
106            public void unregister(Indexer<?> indexer) {
107                    unregister(indexer.getClassName());
108            }
109    
110            @Override
111            public void unregister(String className) {
112                    ServiceRegistration<Indexer<?>> serviceRegistration =
113                            _serviceRegistrations.remove(className);
114    
115                    if (serviceRegistration != null) {
116                            serviceRegistration.unregister();
117                    }
118            }
119    
120            private static final Log _log = LogFactoryUtil.getLog(
121                    TestIndexerRegistry.class);
122    
123            private final Indexer<?> _dummyIndexer = new DummyIndexer();
124            private final Map<String, Indexer<? extends Object>> _indexers =
125                    new ConcurrentHashMap<>();
126            private final StringServiceRegistrationMap<Indexer<?>>
127                    _serviceRegistrations = new StringServiceRegistrationMapImpl<>();
128            private ServiceTracker<Indexer<?>, Indexer<?>> _serviceTracker;
129    
130            private class IndexerServiceTrackerCustomizer
131                    implements ServiceTrackerCustomizer<Indexer<?>, Indexer<?>> {
132    
133                    @Override
134                    public Indexer<?> addingService(
135                            ServiceReference<Indexer<?>> serviceReference) {
136    
137                            Registry registry = RegistryUtil.getRegistry();
138    
139                            Indexer<?> indexer = registry.getService(serviceReference);
140    
141                            Class<?> clazz = indexer.getClass();
142    
143                            _indexers.put(clazz.getName(), indexer);
144    
145                            _indexers.put(indexer.getClassName(), indexer);
146    
147                            return indexer;
148                    }
149    
150                    @Override
151                    public void modifiedService(
152                            ServiceReference<Indexer<?>> serviceReference, Indexer<?> indexer) {
153                    }
154    
155                    @Override
156                    public void removedService(
157                            ServiceReference<Indexer<?>> serviceReference, Indexer<?> indexer) {
158    
159                            Registry registry = RegistryUtil.getRegistry();
160    
161                            registry.ungetService(serviceReference);
162    
163                            Class<?> clazz = indexer.getClass();
164    
165                            _indexers.remove(clazz.getName());
166    
167                            _indexers.remove(indexer.getClassName());
168                    }
169    
170            }
171    
172    }