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.portlet.documentlibrary.util;
016    
017    import com.liferay.portal.kernel.log.Log;
018    import com.liferay.portal.kernel.log.LogFactoryUtil;
019    import com.liferay.portal.kernel.repository.model.FileEntry;
020    import com.liferay.portal.kernel.repository.model.FileVersion;
021    import com.liferay.portal.kernel.security.pacl.DoPrivileged;
022    import com.liferay.portal.kernel.util.ClassLoaderUtil;
023    import com.liferay.portal.kernel.util.InstanceFactory;
024    import com.liferay.portal.kernel.util.PropsKeys;
025    import com.liferay.portal.kernel.util.PropsUtil;
026    import com.liferay.portal.kernel.xml.Element;
027    import com.liferay.portal.util.PrefsPropsUtil;
028    import com.liferay.portal.util.PropsValues;
029    import com.liferay.portlet.exportimport.lar.PortletDataContext;
030    import com.liferay.registry.Registry;
031    import com.liferay.registry.RegistryUtil;
032    import com.liferay.registry.ServiceReference;
033    import com.liferay.registry.ServiceRegistration;
034    import com.liferay.registry.collections.ServiceReferenceMapper;
035    import com.liferay.registry.collections.ServiceTrackerCollections;
036    import com.liferay.registry.collections.ServiceTrackerMap;
037    import com.liferay.registry.collections.StringServiceRegistrationMap;
038    import com.liferay.registry.collections.StringServiceRegistrationMapImpl;
039    
040    /**
041     * @author Mika Koivisto
042     */
043    @DoPrivileged
044    public class DLProcessorRegistryImpl implements DLProcessorRegistry {
045    
046            public void afterPropertiesSet() throws Exception {
047                    ClassLoader classLoader = ClassLoaderUtil.getPortalClassLoader();
048    
049                    for (String dlProcessorClassName : _DL_FILE_ENTRY_PROCESSORS) {
050                            DLProcessor dlProcessor = (DLProcessor)InstanceFactory.newInstance(
051                                    classLoader, dlProcessorClassName);
052    
053                            dlProcessor.afterPropertiesSet();
054    
055                            register(dlProcessor);
056                    }
057            }
058    
059            @Override
060            public void cleanUp(FileEntry fileEntry) {
061                    if (!DLProcessorThreadLocal.isEnabled()) {
062                            return;
063                    }
064    
065                    Iterable<String> dlProcessorTypes =
066                            _dlProcessorServiceTrackerMap.keySet();
067    
068                    for (String dlProcessorType : dlProcessorTypes) {
069                            DLProcessor dlProcessor = _dlProcessorServiceTrackerMap.getService(
070                                    dlProcessorType);
071    
072                            if (dlProcessor.isSupported(fileEntry.getMimeType())) {
073                                    dlProcessor.cleanUp(fileEntry);
074                            }
075                    }
076            }
077    
078            @Override
079            public void cleanUp(FileVersion fileVersion) {
080                    if (!DLProcessorThreadLocal.isEnabled()) {
081                            return;
082                    }
083    
084                    Iterable<String> dlProcessorTypes =
085                            _dlProcessorServiceTrackerMap.keySet();
086    
087                    for (String dlProcessorType : dlProcessorTypes) {
088                            DLProcessor dlProcessor = _dlProcessorServiceTrackerMap.getService(
089                                    dlProcessorType);
090    
091                            if (dlProcessor.isSupported(fileVersion)) {
092                                    dlProcessor.cleanUp(fileVersion);
093                            }
094                    }
095            }
096    
097            @Override
098            public void exportGeneratedFiles(
099                            PortletDataContext portletDataContext, FileEntry fileEntry,
100                            Element fileEntryElement)
101                    throws Exception {
102    
103                    if ((fileEntry == null) || (fileEntry.getSize() == 0)) {
104                            return;
105                    }
106    
107                    FileVersion latestFileVersion = _getLatestFileVersion(fileEntry, true);
108    
109                    if (latestFileVersion == null) {
110                            return;
111                    }
112    
113                    Iterable<String> dlProcessorTypes =
114                            _dlProcessorServiceTrackerMap.keySet();
115    
116                    for (String dlProcessorType : dlProcessorTypes) {
117                            DLProcessor dlProcessor = _dlProcessorServiceTrackerMap.getService(
118                                    dlProcessorType);
119    
120                            if (dlProcessor.isSupported(latestFileVersion)) {
121                                    dlProcessor.exportGeneratedFiles(
122                                            portletDataContext, fileEntry, fileEntryElement);
123                            }
124                    }
125            }
126    
127            @Override
128            public DLProcessor getDLProcessor(String dlProcessorType) {
129                    return _dlProcessorServiceTrackerMap.getService(dlProcessorType);
130            }
131    
132            @Override
133            public void importGeneratedFiles(
134                            PortletDataContext portletDataContext, FileEntry fileEntry,
135                            FileEntry importedFileEntry, Element fileEntryElement)
136                    throws Exception {
137    
138                    if ((importedFileEntry == null) || (importedFileEntry.getSize() == 0)) {
139                            return;
140                    }
141    
142                    FileVersion fileVersion = importedFileEntry.getFileVersion();
143    
144                    if (fileVersion == null) {
145                            return;
146                    }
147    
148                    Iterable<String> dlProcessorTypes =
149                            _dlProcessorServiceTrackerMap.keySet();
150    
151                    for (String dlProcessorType : dlProcessorTypes) {
152                            DLProcessor dlProcessor = _dlProcessorServiceTrackerMap.getService(
153                                    dlProcessorType);
154    
155                            if (dlProcessor.isSupported(fileVersion)) {
156                                    dlProcessor.importGeneratedFiles(
157                                            portletDataContext, fileEntry, importedFileEntry,
158                                            fileEntryElement);
159                            }
160                    }
161            }
162    
163            @Override
164            public boolean isPreviewableSize(FileVersion fileVersion) {
165                    long fileEntryPreviewableProcessorMaxSize =
166                            PropsValues.DL_FILE_ENTRY_PREVIEWABLE_PROCESSOR_MAX_SIZE;
167    
168                    try {
169                            fileEntryPreviewableProcessorMaxSize = PrefsPropsUtil.getLong(
170                                    PropsKeys.DL_FILE_ENTRY_PREVIEWABLE_PROCESSOR_MAX_SIZE);
171                    }
172                    catch (Exception e) {
173                            _log.error(e, e);
174                    }
175    
176                    if (fileEntryPreviewableProcessorMaxSize == 0) {
177                            return false;
178                    }
179    
180                    if ((fileEntryPreviewableProcessorMaxSize > 0) &&
181                            (fileVersion.getSize() > fileEntryPreviewableProcessorMaxSize)) {
182    
183                            return false;
184                    }
185    
186                    return true;
187            }
188    
189            @Override
190            public void register(DLProcessor dlProcessor) {
191                    Registry registry = RegistryUtil.getRegistry();
192    
193                    ServiceRegistration<DLProcessor> previousServiceRegistration =
194                            _serviceRegistrations.remove(dlProcessor.getType());
195    
196                    if (previousServiceRegistration != null) {
197                            previousServiceRegistration.unregister();
198                    }
199    
200                    ServiceRegistration<DLProcessor> serviceRegistration =
201                            registry.registerService(DLProcessor.class, dlProcessor);
202    
203                    _serviceRegistrations.put(dlProcessor.getType(), serviceRegistration);
204            }
205    
206            @Override
207            public void trigger(FileEntry fileEntry, FileVersion fileVersion) {
208                    trigger(fileEntry, fileVersion, false);
209            }
210    
211            @Override
212            public void trigger(
213                    FileEntry fileEntry, FileVersion fileVersion, boolean trusted) {
214    
215                    if (!DLProcessorThreadLocal.isEnabled()) {
216                            return;
217                    }
218    
219                    if ((fileEntry == null) || (fileEntry.getSize() == 0)) {
220                            return;
221                    }
222    
223                    FileVersion latestFileVersion = _getLatestFileVersion(
224                            fileEntry, trusted);
225    
226                    if (latestFileVersion == null) {
227                            return;
228                    }
229    
230                    Iterable<String> dlProcessorTypes =
231                            _dlProcessorServiceTrackerMap.keySet();
232    
233                    for (String dlProcessorType : dlProcessorTypes) {
234                            DLProcessor dlProcessor = _dlProcessorServiceTrackerMap.getService(
235                                    dlProcessorType);
236    
237                            if (dlProcessor.isSupported(latestFileVersion)) {
238                                    dlProcessor.trigger(fileVersion, latestFileVersion);
239                            }
240                    }
241            }
242    
243            @Override
244            public void unregister(DLProcessor dlProcessor) {
245                    ServiceRegistration<DLProcessor> serviceRegistration =
246                            _serviceRegistrations.remove(dlProcessor.getType());
247    
248                    serviceRegistration.unregister();
249            }
250    
251            private FileVersion _getLatestFileVersion(
252                    FileEntry fileEntry, boolean trusted) {
253    
254                    try {
255                            return fileEntry.getLatestFileVersion(trusted);
256                    }
257                    catch (Exception e) {
258                            _log.error(e, e);
259    
260                            return null;
261                    }
262            }
263    
264            private static final String[] _DL_FILE_ENTRY_PROCESSORS =
265                    PropsUtil.getArray(PropsKeys.DL_FILE_ENTRY_PROCESSORS);
266    
267            private static final Log _log = LogFactoryUtil.getLog(
268                    DLProcessorRegistryImpl.class);
269    
270            private final ServiceTrackerMap<String, DLProcessor>
271                    _dlProcessorServiceTrackerMap =
272                            ServiceTrackerCollections.openSingleValueMap(
273                                    DLProcessor.class, null,
274                                    new ServiceReferenceMapper<String, DLProcessor>() {
275    
276                                            @Override
277                                            public void map(
278                                                    ServiceReference<DLProcessor> serviceReference,
279                                                    Emitter<String> emitter) {
280    
281                                                    Registry registry = RegistryUtil.getRegistry();
282    
283                                                    DLProcessor dlProcessor = registry.getService(
284                                                            serviceReference);
285    
286                                                    try {
287                                                            emitter.emit(dlProcessor.getType());
288                                                    }
289                                                    finally {
290                                                            registry.ungetService(serviceReference);
291                                                    }
292                                            }
293    
294                                    });
295    
296            private final StringServiceRegistrationMap<DLProcessor>
297                    _serviceRegistrations = new StringServiceRegistrationMapImpl<>();
298    
299    }