Xinwen Deng / aem-src

/*
 * Decompiled with CFR 0_118.
 * 
 * Could not load the following classes:
 *  com.adobe.jmx.JMXService
 *  com.adobe.jmx.statistics.StatisticsProvider
 *  org.apache.commons.io.FileUtils
 *  org.apache.commons.io.FilenameUtils
 *  org.apache.commons.lang.Validate
 *  org.apache.felix.scr.annotations.Activate
 *  org.apache.felix.scr.annotations.Component
 *  org.apache.felix.scr.annotations.Deactivate
 *  org.apache.felix.scr.annotations.Reference
 *  org.osgi.framework.BundleContext
 *  org.osgi.framework.ServiceRegistration
 *  org.slf4j.Logger
 */
package com.adobe.service;

import com.adobe.aemds.bedrock.CoreConfigService;
import com.adobe.jmx.JMXService;
import com.adobe.jmx.statistics.StatisticsProvider;
import com.adobe.service.*;
import org.apache.commons.io.FileUtils;
import org.apache.commons.io.FilenameUtils;
import org.apache.commons.lang.Validate;
import org.apache.felix.scr.annotations.Activate;
import org.apache.felix.scr.annotations.Component;
import org.apache.felix.scr.annotations.Deactivate;
import org.apache.felix.scr.annotations.Reference;
import org.osgi.framework.BundleContext;
import org.osgi.framework.ServiceRegistration;

import javax.management.ObjectInstance;
import javax.management.ObjectName;
import java.io.File;
import java.io.IOException;
import java.lang.reflect.UndeclaredThrowableException;
import java.util.*;

@Component(componentAbstract=1)
public abstract class Service
extends ServiceAPI
implements ServiceMBean {
    private ObjectInstance registeredMBean;
    private ProcessAttributes processAttributesDelegate;
    private ServiceRegistration registration;
    @Reference
    private CoreConfigService coreConfigService;
    @Reference
    private JMXService jmxService;
    private String tempDirPath;
    private String nativeDirPath;
    private String persistentDirPath;
    private BundleContext bundleContext;
    private Map config;
    protected StatisticsProvider mbean;
    protected Map<String, Object> badAttrMap = Collections.synchronizedMap(new HashMap());

    @Activate
    protected final void activate(BundleContext bundleContext, Map config) throws Exception {
        this.bundleContext = bundleContext;
        this.config = config;
        this.initializeStatisticsHost();
        this.initialize();
        this.registerMBean();
    }

    @Deactivate
    protected final void deactivate() {
        this.logger.debug("Deactivating instance {} of service {}", (Object)this, (Object)this.getName());
        this.stop();
        this.unregisterMBean();
    }

    protected abstract void onStartService(Map var1);

    protected void onStopService() {
    }

    public void disableService() {
        this.logger.info("Service {}: Disabling", (Object)this);
        try {
            this.shutdown();
        }
        catch (Exception e) {
            this.logger.warn("Error during service shutdown", (Throwable)e);
        }
    }

    private void bindService(String name, ConnectionFactory cf) {
        BundleContext bc = this.getBundleContext();
        Hashtable<String, String> p = new Hashtable<String, String>();
        p.put("bmc.service.name", name);
        this.registration = bc.registerService(ConnectionFactory.class.getName(), (Object)cf, p);
    }

    public void registerConnectionFactoryManager(ResourceFactoryManager inConnectionFactoryManager) {
        if (inConnectionFactoryManager instanceof ConnectionFactoryManager) {
            this.setConnectionFactoryManager((ConnectionFactoryManager)inConnectionFactoryManager);
        }
        if (inConnectionFactoryManager instanceof ProcessAttributes) {
            this.processAttributesDelegate = (ProcessAttributes)((Object)this.getConnectionFactoryManager());
        }
        String ctxPath = this.getName();
        try {
            if (inConnectionFactoryManager instanceof SingletonFactoryManager) {
                SingletonFactoryManager sfm = (SingletonFactoryManager)inConnectionFactoryManager;
                this.logger.debug("Creating Singleton CF Manager for service {}", (Object)this);
                ConnectionFactory cf = sfm.getConnectionFactory();
                this.logger.debug("Trying to bind ConnectionFactory: " + cf + " to context: " + ctxPath, (Object)this);
                this.bindService(ctxPath, cf);
            } else {
                this.logger.debug("Creating CF Manager for service {}", (Object)this);
                this.logger.debug("Trying to bind ConnectionFactory: " + this.getConnectionFactoryManager().getConnectionFactory() + " to context: " + ctxPath, (Object)this);
                this.bindService(ctxPath, this.getConnectionFactoryManager().getConnectionFactory());
            }
        }
        catch (Throwable e) {
            this.logger.error("Unexpected exception while creating singleton service", e);
        }
    }

    private void unregisterConnectionFactoryManager() {
        try {
            this.logger.debug("Unregistering connection factory {} for service {}", (Object)this, (Object)this.getName());
            if (this.registration != null) {
                this.registration.unregister();
                this.registration = null;
            }
        }
        catch (IllegalStateException e) {
            this.logger.debug("Exception while unregistering connection factory, likely due to the current service being a dummy one: {}", (Throwable)e);
        }
        catch (Throwable exc) {
            this.logger.error("Unexpected exception while unregistering connection factory for service {}: {}", (Object)this.getName(), (Object)exc);
        }
        ConnectionFactoryManager cfm = this.getConnectionFactoryManager();
        if (cfm != null) {
            cfm.onShutdown();
        }
    }

    public File getDeployedFile(String inPath) {
        File deployedFile = null;
        if (File.pathSeparatorChar == '\\') {
            inPath = inPath.replace('/', File.pathSeparatorChar);
        }
        try {
            String parentDir = this.getPersistentDir().getCanonicalPath();
            deployedFile = new File(parentDir, inPath).getAbsoluteFile();
            this.logger.debug("Got DeployedFile: {}, {}", (Object)parentDir, (Object)inPath);
        }
        catch (Throwable exc) {
            this.logger.error("Unexpected exception while getting deployed file", exc);
        }
        return deployedFile;
    }

    public File getTempDir() {
        if (this.tempDirPath == null) {
            this.tempDirPath = this.createDirectory(this.getServerTempDir(), this.getName());
        }
        return new File(this.tempDirPath);
    }

    public File getNativeDir() {
        if (this.nativeDirPath == null) {
            this.nativeDirPath = this.createDirectory(this.getServerNativeDir(), this.getName());
        }
        return new File(this.nativeDirPath);
    }

    public File getPersistentDir() {
        if (this.persistentDirPath == null) {
            this.persistentDirPath = this.createDirectory(this.getServerDataDir(), this.getName());
        }
        return new File(this.persistentDirPath);
    }

    public void setExecutableName(String executableName) {
        this.processAttributesDelegate.setExecutableName(executableName);
    }

    public String getExecutableName() {
        return this.processAttributesDelegate.getExecutableName();
    }

    public void setJVMArgs(String jvmArgs) {
        this.processAttributesDelegate.setJVMArgs(jvmArgs);
    }

    public String getJVMArgs() {
        return this.processAttributesDelegate.getJVMArgs();
    }

    public void setClassPath(String classPath) {
        this.processAttributesDelegate.setClassPath(classPath);
    }

    public String getClassPath() {
        return this.processAttributesDelegate.getClassPath();
    }

    public void setSharedLibraryPaths(String[] paths) {
        this.processAttributesDelegate.setSharedLibraryPaths(paths);
    }

    public String[] getSharedLibraryPaths() {
        return this.processAttributesDelegate.getSharedLibraryPaths();
    }

    public void setExecutableArguments(String args) {
        this.processAttributesDelegate.setExecutableArguments(args);
    }

    public String getExecutableArguments() {
        return this.processAttributesDelegate.getExecutableArguments();
    }

    public boolean getDebug() {
        return this.processAttributesDelegate.getDebug();
    }

    public void setDebug(boolean inDebug) {
        this.processAttributesDelegate.setDebug(inDebug);
    }

    public int getMaximumReUseCount() {
        return this.processAttributesDelegate.getMaximumReUseCount();
    }

    public void setMaximumReUseCount(int count) {
        this.processAttributesDelegate.setMaximumReUseCount(count);
    }

    public String getORBParams() {
        return this.processAttributesDelegate.getORBParams();
    }

    public void setORBParams(String params) {
        this.processAttributesDelegate.setORBParams(params);
    }

    public String getNativeDependencies() {
        return this.processAttributesDelegate.getNativeDependencies();
    }

    public void setNativeDependencies(String nativeDependencies) {
        this.processAttributesDelegate.setNativeDependencies(nativeDependencies);
    }

    public StatisticsProvider getStatisticsProvider() {
        return this.mbean;
    }

    public CoreConfigService getCoreConfigService() {
        Validate.notNull((Object)this.coreConfigService, (String)"CoreConfigService reference not initialized");
        return this.coreConfigService;
    }

    public void setCoreConfigService(CoreConfigService coreConfigService) {
        this.coreConfigService = coreConfigService;
    }

    /*
     * WARNING - Removed try catching itself - possible behaviour change.
     */
    protected void initialize() throws Exception {
        ClassLoader oldCl = Thread.currentThread().getContextClassLoader();
        try {
            Thread.currentThread().setContextClassLoader(this.getClass().getClassLoader());
            this.start();
            Object var3_2 = null;
            Thread.currentThread().setContextClassLoader(oldCl);
        }
        catch (Throwable var2_4) {
            Object var3_3 = null;
            Thread.currentThread().setContextClassLoader(oldCl);
            throw var2_4;
        }
    }

    private void start() throws Exception {
        this.setState(SERVICE_STARTING);
        this.setStartTime(System.currentTimeMillis());
        this.logger.debug("Service {}: Starting", (Object)this);
        this.logger.trace("Calling out to service {} onStartService.", (Object)this);
        this.onStartService(this.config);
        this.logger.trace("Returned from service {} onStartService.", (Object)this);
        this.retryBadProperties();
        this.setState(SERVICE_RUNNING);
        this.logger.debug("Service {}: Started", (Object)this);
    }

    private void retryBadProperties() {
        for (String key : this.badAttrMap.keySet()) {
            try {
                this.setAttribute(key, this.badAttrMap.get(key));
            }
            catch (Exception e) {
                this.logger.error("Unexpected exception while setting attribute " + key, (Throwable)e);
            }
        }
    }

    protected void initializePropertiesFromResourceBundle() {
        Properties props = new Properties();
        String bundleName = "com/adobe/config/" + this.getName() + "-init";
        try {
            ResourceBundle labels = ResourceBundle.getBundle(bundleName, Locale.getDefault(), this.getClass().getClassLoader());
            Enumeration<String> names = labels.getKeys();
            while (names.hasMoreElements()) {
                String name = names.nextElement().toString();
                props.put(name, labels.getObject(name));
            }
            this.logger.debug("Loaded properties from {}", (Object)bundleName);
            this.setAttributes(props);
            this.logger.debug("Combined properties table: ", (Object)props.toString());
        }
        catch (MissingResourceException e) {
            this.logger.debug("Exception thrown for missing config properties file: ", (Throwable)e);
            this.logger.debug("Service {}: missing config properties file {}", (Object)this.getName(), (Object)bundleName);
        }
        catch (Exception e) {
            this.logger.error("Service " + this + ": Missing initialization properties " + bundleName, (Throwable)e);
        }
    }

    private void stop() {
        this.setState(SERVICE_STOPPING);
        this.logger.debug("Service {}: Stopping", (Object)this);
        this.logger.trace("Calling out to service {} onStopService.", (Object)this);
        this.onStopService();
        this.logger.trace("Returned from service {} onStopService.", (Object)this);
        this.unregisterConnectionFactoryManager();
        this.deleteTempDir();
        this.setState(SERVICE_STOPPED);
        this.logger.debug("Service {}: Stopped", (Object)this);
    }

    private void registerMBean() {
        try {
            this.registeredMBean = this.jmxService.registerMBeanIfPossible((Object)this.mbean, this.mbean.getObjectName());
        }
        catch (Exception e) {
            this.logger.error("Unexpected exception while registering MBean", (Throwable)e);
            throw new UndeclaredThrowableException(e, "Can't register MBean for " + this);
        }
    }

    private void initializeStatisticsHost() {
        ObjectName objectName = this.jmxService.makeName("AdobeService", this.getName());
        this.mbean = new StatisticsProvider(objectName);
        this.mbean.addReflectionTarget((Object)this);
    }

    private void unregisterMBean() {
        if (this.registeredMBean != null) {
            this.jmxService.unregisterMBean(this.registeredMBean.getObjectName());
        }
    }

    protected void shutdown() {
        this.stop();
    }

    protected BundleContext getBundleContext() {
        Validate.notNull((Object)this.bundleContext, (String)"BundleContext not initialized");
        return this.bundleContext;
    }

    private String getServerDataDir() {
        return this.getCoreConfigService().getServerDataDir();
    }

    private String getServerTempDir() {
        return this.getCoreConfigService().getServerTempDir();
    }

    private String getServerNativeDir() {
        return this.getCoreConfigService().getServerNativeDir();
    }

    private void deleteTempDir() {
        if (this.tempDirPath != null) {
            FileUtils.deleteQuietly((File)new File(this.tempDirPath));
        }
    }

    private String createDirectory(String baseDir, String subDirName) {
        String dir = FilenameUtils.concat((String)baseDir, (String)subDirName);
        File tempDir = new File(dir);
        try {
            FileUtils.forceMkdir((File)tempDir);
            dir = tempDir.getCanonicalPath();
        }
        catch (IOException e) {
            throw new RuntimeException("Error creating directory for Service '" + this.getName() + "' using name '" + dir + "'", e);
        }
        return dir;
    }

    protected void bindCoreConfigService(CoreConfigService coreConfigService) {
        this.coreConfigService = coreConfigService;
    }

    protected void unbindCoreConfigService(CoreConfigService coreConfigService) {
        if (this.coreConfigService == coreConfigService) {
            this.coreConfigService = null;
        }
    }

    protected void bindJmxService(JMXService jMXService) {
        this.jmxService = jMXService;
    }

    protected void unbindJmxService(JMXService jMXService) {
        if (this.jmxService == jMXService) {
            this.jmxService = null;
        }
    }
}