001    /**
002     * Licensed to the Apache Software Foundation (ASF) under one
003     * or more contributor license agreements.  See the NOTICE file
004     * distributed with this work for additional information
005     * regarding copyright ownership.  The ASF licenses this file
006     * to you under the Apache License, Version 2.0 (the
007     * "License"); you may not use this file except in compliance
008     * with the License.  You may obtain a copy of the License at
009     *
010     *      http://www.apache.org/licenses/LICENSE-2.0
011     *
012     * Unless required by applicable law or agreed to in writing, software
013     * distributed under the License is distributed on an "AS IS" BASIS,
014     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
015     * See the License for the specific language governing permissions and
016     * limitations under the License.
017     */
018    package org.apache.oozie.service;
019    
020    import org.apache.commons.logging.LogFactory;
021    import org.apache.hadoop.conf.Configuration;
022    import org.apache.hadoop.util.ReflectionUtils;
023    import org.apache.hadoop.util.VersionInfo;
024    import org.apache.oozie.BuildInfo;
025    import org.apache.oozie.client.OozieClient.SYSTEM_MODE;
026    import org.apache.oozie.util.DateUtils;
027    import org.apache.oozie.util.XLog;
028    import org.apache.oozie.util.Instrumentable;
029    import org.apache.oozie.util.Instrumentation;
030    import org.apache.oozie.util.IOUtils;
031    import org.apache.oozie.ErrorCode;
032    
033    import java.util.ArrayList;
034    import java.util.Collections;
035    import java.util.LinkedHashMap;
036    import java.util.List;
037    import java.util.Map;
038    import java.io.IOException;
039    import java.io.File;
040    
041    /**
042     * Services is a singleton that manages the lifecycle of all registered {@link Services}. <p/> It has 2 built in
043     * services: {@link XLogService} and {@link ConfigurationService}. <p/> The rest of the services are loaded from the
044     * {@link #CONF_SERVICE_CLASSES} configuration property. The services class names must be separated by commas (spaces
045     * and enters are allowed). <p/> The {@link #CONF_SYSTEM_MODE} configuration property is any of
046     * NORMAL/SAFEMODE/NOWEBSERVICE. <p/> Services are loaded and initialized in the order they are defined in the in
047     * configuration property. <p/> After all services are initialized, if the Instrumentation service is present, all
048     * services that implement the {@link Instrumentable} are instrumented. <p/> Services are destroyed in reverse order.
049     * <p/> If services initialization fail, initialized services are immediatly destroyed.
050     */
051    public class Services {
052        private static final int MAX_SYSTEM_ID_LEN = 10;
053    
054        /**
055         * Environment variable that indicates the location of the Oozie home directory.
056         * The Oozie home directory is used to pick up the conf/ directory from
057         */
058        public static final String OOZIE_HOME_DIR = "oozie.home.dir";
059    
060        public static final String CONF_SYSTEM_ID = "oozie.system.id";
061    
062        public static final String CONF_SERVICE_CLASSES = "oozie.services";
063    
064        public static final String CONF_SERVICE_EXT_CLASSES = "oozie.services.ext";
065    
066        public static final String CONF_SYSTEM_MODE = "oozie.systemmode";
067    
068        public static final String CONF_DELETE_RUNTIME_DIR = "oozie.delete.runtime.dir.on.shutdown";
069    
070        private static Services SERVICES;
071    
072        private SYSTEM_MODE systemMode;
073        private String runtimeDir;
074        private Configuration conf;
075        private Map<Class<? extends Service>, Service> services = new LinkedHashMap<Class<? extends Service>, Service>();
076        private String systemId;
077        private static String oozieHome;
078    
079        public static void setOozieHome() throws ServiceException {
080            oozieHome = System.getProperty(OOZIE_HOME_DIR);
081            if (oozieHome == null) {
082                throw new ServiceException(ErrorCode.E0000);
083            }
084            File file = new File(oozieHome);
085            if (!file.isAbsolute()) {
086                throw new ServiceException(ErrorCode.E0003, oozieHome);
087            }
088            if (!file.exists()) {
089                throw new ServiceException(ErrorCode.E0004, oozieHome);
090            }
091        }
092    
093        public static String getOozieHome() throws ServiceException {
094            return oozieHome;
095        }
096    
097        /**
098         * Create a services. <p/> The built in services are initialized.
099         *
100         * @throws ServiceException thrown if any of the built in services could not initialize.
101         */
102        public Services() throws ServiceException {
103            setOozieHome();
104            if (SERVICES != null) {
105                XLog log = XLog.getLog(getClass());
106                log.warn(XLog.OPS, "Previous services singleton active, destroying it");
107                SERVICES.destroy();
108                SERVICES = null;
109            }
110            setServiceInternal(XLogService.class, false);
111            setServiceInternal(ConfigurationService.class, true);
112            conf = get(ConfigurationService.class).getConf();
113            DateUtils.setConf(conf);
114            if (!DateUtils.getOozieProcessingTimeZone().equals(DateUtils.UTC)) {
115                XLog.getLog(getClass()).warn("Oozie configured to work in a timezone other than UTC: {0}",
116                                             DateUtils.getOozieProcessingTimeZone().getID());
117            }
118            systemId = conf.get(CONF_SYSTEM_ID, ("oozie-" + System.getProperty("user.name")));
119            if (systemId.length() > MAX_SYSTEM_ID_LEN) {
120                systemId = systemId.substring(0, MAX_SYSTEM_ID_LEN);
121                XLog.getLog(getClass()).warn("System ID [{0}] exceeds maximum length [{1}], trimming", systemId,
122                                             MAX_SYSTEM_ID_LEN);
123            }
124            setSystemMode(SYSTEM_MODE.valueOf(conf.get(CONF_SYSTEM_MODE, SYSTEM_MODE.NORMAL.toString())));
125            runtimeDir = createRuntimeDir();
126        }
127    
128        private String createRuntimeDir() throws ServiceException {
129            try {
130                File file = File.createTempFile(getSystemId(), ".dir");
131                file.delete();
132                if (!file.mkdir()) {
133                    ServiceException ex = new ServiceException(ErrorCode.E0001, file.getAbsolutePath());
134                    XLog.getLog(getClass()).fatal(ex);
135                    throw ex;
136                }
137                XLog.getLog(getClass()).info("Initialized runtime directory [{0}]", file.getAbsolutePath());
138                return file.getAbsolutePath();
139            }
140            catch (IOException ex) {
141                ServiceException sex = new ServiceException(ErrorCode.E0001, "", ex);
142                XLog.getLog(getClass()).fatal(ex);
143                throw sex;
144            }
145        }
146    
147        /**
148         * Return active system mode. <p/> .
149         *
150         * @return
151         */
152    
153        public SYSTEM_MODE getSystemMode() {
154            return systemMode;
155        }
156    
157        /**
158         * Return the runtime directory of the Oozie instance. <p/> The directory is created under TMP and it is always a
159         * new directory per Services initialization.
160         *
161         * @return the runtime directory of the Oozie instance.
162         */
163        public String getRuntimeDir() {
164            return runtimeDir;
165        }
166    
167        /**
168         * Return the system ID, the value defined in the {@link #CONF_SYSTEM_ID} configuration property.
169         *
170         * @return the system ID, the value defined in the {@link #CONF_SYSTEM_ID} configuration property.
171         */
172        public String getSystemId() {
173            return systemId;
174        }
175    
176        /**
177         * Set and set system mode.
178         *
179         * @param sysMode system mode
180         */
181    
182        public synchronized void setSystemMode(SYSTEM_MODE sysMode) {
183            if (this.systemMode != sysMode) {
184                XLog log = XLog.getLog(getClass());
185                log.info(XLog.OPS, "Exiting " + this.systemMode + " Entering " + sysMode);
186            }
187            this.systemMode = sysMode;
188        }
189    
190        /**
191         * Return the services configuration.
192         *
193         * @return services configuraiton.
194         */
195        public Configuration getConf() {
196            return conf;
197        }
198    
199        /**
200         * Initialize all services define in the {@link #CONF_SERVICE_CLASSES} configuration property.
201         *
202         * @throws ServiceException thrown if any of the services could not initialize.
203         */
204        @SuppressWarnings("unchecked")
205        public void init() throws ServiceException {
206            XLog log = new XLog(LogFactory.getLog(getClass()));
207            log.trace("Initializing");
208            SERVICES = this;
209            try {
210                loadServices();
211            }
212            catch (RuntimeException rex) {
213                XLog.getLog(getClass()).fatal(rex.getMessage(), rex);
214                throw rex;
215            }
216            catch (ServiceException ex) {
217                XLog.getLog(getClass()).fatal(ex.getMessage(), ex);
218                SERVICES = null;
219                throw ex;
220            }
221            InstrumentationService instrService = get(InstrumentationService.class);
222            if (instrService != null) {
223                Instrumentation instr = instrService.get();
224                for (Service service : services.values()) {
225                    if (service instanceof Instrumentable) {
226                        ((Instrumentable) service).instrument(instr);
227                    }
228                }
229                instr.addVariable("oozie", "version", new Instrumentation.Variable<String>() {
230                    @Override
231                    public String getValue() {
232                        return BuildInfo.getBuildInfo().getProperty(BuildInfo.BUILD_VERSION);
233                    }
234                });
235                instr.addVariable("oozie", "mode", new Instrumentation.Variable<String>() {
236                    @Override
237                    public String getValue() {
238                        return getSystemMode().toString();
239                    }
240                });
241            }
242            log.info("Initialized");
243            log.info("Running with JARs for Hadoop version [{0}]", VersionInfo.getVersion());
244            log.info("Oozie System ID [{0}] started!", getSystemId());
245        }
246    
247        /**
248         * Loads the specified services.
249         *
250         * @param classes services classes to load.
251         * @param list    list of loaded service in order of appearance in the
252         *                configuration.
253         * @throws ServiceException thrown if a service class could not be loaded.
254         */
255        private void loadServices(Class[] classes, List<Service> list) throws ServiceException {
256            XLog log = new XLog(LogFactory.getLog(getClass()));
257            for (Class klass : classes) {
258                try {
259                    Service service = (Service) klass.newInstance();
260                    log.debug("Loading service [{0}] implementation [{1}]", service.getInterface(),
261                            service.getClass());
262                    if (!service.getInterface().isInstance(service)) {
263                        throw new ServiceException(ErrorCode.E0101, klass, service.getInterface().getName());
264                    }
265                    list.add(service);
266                } catch (ServiceException ex) {
267                    throw ex;
268                } catch (Exception ex) {
269                    throw new ServiceException(ErrorCode.E0102, klass, ex.getMessage(), ex);
270                }
271            }
272        }
273    
274        /**
275         * Loads services defined in <code>services</code> and
276         * <code>services.ext</code> and de-dups them.
277         *
278         * @return List of final services to initialize.
279         * @throws ServiceException throw if the services could not be loaded.
280         */
281        private void loadServices() throws ServiceException {
282            XLog log = new XLog(LogFactory.getLog(getClass()));
283            try {
284                Map<Class, Service> map = new LinkedHashMap<Class, Service>();
285                Class[] classes = conf.getClasses(CONF_SERVICE_CLASSES);
286                log.debug("Services list obtained from property '" + CONF_SERVICE_CLASSES + "'");
287                Class[] classesExt = conf.getClasses(CONF_SERVICE_EXT_CLASSES);
288                log.debug("Services list obtained from property '" + CONF_SERVICE_EXT_CLASSES + "'");
289                List<Service> list = new ArrayList<Service>();
290                loadServices(classes, list);
291                loadServices(classesExt, list);
292    
293                //removing duplicate services, strategy: last one wins
294                for (Service service : list) {
295                    if (map.containsKey(service.getInterface())) {
296                        log.debug("Replacing service [{0}] implementation [{1}]", service.getInterface(),
297                                service.getClass());
298                    }
299                    map.put(service.getInterface(), service);
300                }
301                for (Map.Entry<Class, Service> entry : map.entrySet()) {
302                    setService(entry.getValue().getClass());
303                }
304            } catch (RuntimeException rex) {
305                log.fatal("Runtime Exception during Services Load. Check your list of '" + CONF_SERVICE_CLASSES + "' or '" + CONF_SERVICE_EXT_CLASSES + "'");
306                throw new ServiceException(ErrorCode.E0103, rex.getMessage(), rex);
307            }
308        }
309    
310        /**
311         * Destroy all services.
312         */
313        public void destroy() {
314            XLog log = new XLog(LogFactory.getLog(getClass()));
315            log.trace("Shutting down");
316            boolean deleteRuntimeDir = false;
317            if (conf != null) {
318                deleteRuntimeDir = conf.getBoolean(CONF_DELETE_RUNTIME_DIR, false);
319            }
320            if (services != null) {
321                List<Service> list = new ArrayList<Service>(services.values());
322                Collections.reverse(list);
323                for (Service service : list) {
324                    try {
325                        log.trace("Destroying service[{0}]", service.getInterface());
326                        if (service.getInterface() == XLogService.class) {
327                            log.info("Shutdown");
328                        }
329                        service.destroy();
330                    }
331                    catch (Throwable ex) {
332                        log.error("Error destroying service[{0}], {1}", service.getInterface(), ex.getMessage(), ex);
333                    }
334                }
335            }
336            if (deleteRuntimeDir) {
337                try {
338                    IOUtils.delete(new File(runtimeDir));
339                }
340                catch (IOException ex) {
341                    log.error("Error deleting runtime directory [{0}], {1}", runtimeDir, ex.getMessage(), ex);
342                }
343            }
344            services = null;
345            conf = null;
346            SERVICES = null;
347        }
348    
349        /**
350         * Return a service by its public interface.
351         *
352         * @param serviceKlass service public interface.
353         * @return the associated service, or <code>null</code> if not define.
354         */
355        @SuppressWarnings("unchecked")
356        public <T extends Service> T get(Class<T> serviceKlass) {
357            return (T) services.get(serviceKlass);
358        }
359    
360        /**
361         * Set a service programmatically. <p/> The service will be initialized by the services. <p/> If a service is
362         * already defined with the same public interface it will be destroyed.
363         *
364         * @param klass service klass
365         * @throws ServiceException if the service could not be initialized, at this point all services have been
366         * destroyed.
367         */
368        public void setService(Class<? extends Service> klass) throws ServiceException {
369            setServiceInternal(klass, true);
370        }
371    
372        private void setServiceInternal(Class<? extends Service> klass, boolean logging) throws ServiceException {
373            try {
374                Service newService = (Service) ReflectionUtils.newInstance(klass, null);
375                Service oldService = services.get(newService.getInterface());
376                if (oldService != null) {
377                    oldService.destroy();
378                }
379                if (logging) {
380                    XLog log = new XLog(LogFactory.getLog(getClass()));
381                    log.trace("Initializing service[{0}] class[{1}]", newService.getInterface(), newService.getClass());
382                }
383                newService.init(this);
384                services.put(newService.getInterface(), newService);
385            }
386            catch (ServiceException ex) {
387                XLog.getLog(getClass()).fatal(ex.getMessage(), ex);
388                destroy();
389                throw ex;
390            }
391        }
392    
393        /**
394         * Return the services singleton.
395         *
396         * @return services singleton, <code>null</code> if not initialized.
397         */
398        public static Services get() {
399            return SERVICES;
400        }
401    
402    }