Xinwen Deng / aem-src

/*
 * Decompiled with CFR 0_118.
 * 
 * Could not load the following classes:
 *  org.apache.felix.scr.annotations.Activate
 *  org.apache.felix.scr.annotations.Component
 *  org.apache.felix.scr.annotations.Deactivate
 *  org.apache.felix.scr.annotations.Properties
 *  org.apache.felix.scr.annotations.Property
 *  org.apache.felix.scr.annotations.Reference
 *  org.apache.felix.scr.annotations.Service
 *  org.apache.sling.api.resource.LoginException
 *  org.apache.sling.api.resource.Resource
 *  org.apache.sling.api.resource.ResourceResolver
 *  org.apache.sling.api.resource.ResourceResolverFactory
 *  org.apache.sling.api.resource.ResourceUtil
 *  org.apache.sling.api.resource.ValueMap
 *  org.apache.sling.commons.osgi.PropertiesUtil
 *  org.apache.sling.commons.scheduler.Job
 *  org.apache.sling.commons.scheduler.JobContext
 *  org.apache.sling.commons.scheduler.ScheduleOptions
 *  org.apache.sling.commons.scheduler.Scheduler
 *  org.apache.sling.discovery.InstanceDescription
 *  org.apache.sling.discovery.TopologyEvent
 *  org.apache.sling.discovery.TopologyEvent$Type
 *  org.apache.sling.discovery.TopologyEventListener
 *  org.apache.sling.discovery.TopologyView
 *  org.apache.sling.event.jobs.Job
 *  org.apache.sling.event.jobs.JobManager
 *  org.apache.sling.hc.api.HealthCheck
 *  org.apache.sling.launchpad.api.StartupListener
 *  org.apache.sling.launchpad.api.StartupMode
 *  org.osgi.framework.BundleContext
 *  org.osgi.framework.Filter
 *  org.osgi.framework.InvalidSyntaxException
 *  org.osgi.framework.ServiceReference
 *  org.osgi.framework.ServiceRegistration
 *  org.osgi.service.event.Event
 *  org.osgi.service.event.EventHandler
 *  org.osgi.util.tracker.ServiceTracker
 *  org.osgi.util.tracker.ServiceTrackerCustomizer
 *  org.slf4j.Logger
 *  org.slf4j.LoggerFactory
 */
package com.adobe.granite.maintenance.impl;

import com.adobe.granite.maintenance.MaintenanceTaskInfo;
import com.adobe.granite.maintenance.MaintenanceTaskManager;
import com.adobe.granite.maintenance.impl.MaintenanceTaskHealthCheck;
import com.adobe.granite.maintenance.impl.MaintenanceWindowImpl;
import com.adobe.granite.operations.OperationsService;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Collection;
import java.util.Collections;
import java.util.Dictionary;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Hashtable;
import java.util.List;
import java.util.Map;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
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.Properties;
import org.apache.felix.scr.annotations.Property;
import org.apache.felix.scr.annotations.Reference;
import org.apache.felix.scr.annotations.Service;
import org.apache.sling.api.resource.LoginException;
import org.apache.sling.api.resource.Resource;
import org.apache.sling.api.resource.ResourceResolver;
import org.apache.sling.api.resource.ResourceResolverFactory;
import org.apache.sling.api.resource.ResourceUtil;
import org.apache.sling.api.resource.ValueMap;
import org.apache.sling.commons.osgi.PropertiesUtil;
import org.apache.sling.commons.scheduler.JobContext;
import org.apache.sling.commons.scheduler.ScheduleOptions;
import org.apache.sling.commons.scheduler.Scheduler;
import org.apache.sling.discovery.InstanceDescription;
import org.apache.sling.discovery.TopologyEvent;
import org.apache.sling.discovery.TopologyEventListener;
import org.apache.sling.discovery.TopologyView;
import org.apache.sling.event.jobs.Job;
import org.apache.sling.event.jobs.JobManager;
import org.apache.sling.hc.api.HealthCheck;
import org.apache.sling.launchpad.api.StartupListener;
import org.apache.sling.launchpad.api.StartupMode;
import org.osgi.framework.BundleContext;
import org.osgi.framework.Filter;
import org.osgi.framework.InvalidSyntaxException;
import org.osgi.framework.ServiceReference;
import org.osgi.framework.ServiceRegistration;
import org.osgi.service.event.Event;
import org.osgi.service.event.EventHandler;
import org.osgi.util.tracker.ServiceTracker;
import org.osgi.util.tracker.ServiceTrackerCustomizer;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

@Component(immediate=1, metatype=1, label="Adobe Granite Maintenance Scheduler", description="Scheduler for the maintenance tasks.")
@Service(value={EventHandler.class, TopologyEventListener.class, StartupListener.class})
@Properties(value={@Property(name="event.topics", value={"org/apache/sling/api/resource/Resource/ADDED", "org/apache/sling/api/resource/Resource/REMOVED", "org/apache/sling/api/resource/Resource/CHANGED", "org/apache/sling/event/notification/job/CANCELLED"}, propertyPrivate=1)})
public class TaskScheduler
implements org.apache.sling.commons.scheduler.Job,
EventHandler,
TopologyEventListener,
StartupListener {
    private final Logger logger;
    private static final String DEFAULT_PATH = "/mnt/overlay";
    @Property(value={"/mnt/overlay"}, label="Base Path", description="Resource base path to the window definitions. The configuration path is appended to the base path.")
    private static final String PROPERTY_PATH = "resourcePath";
    private static final String DEFAULT_CONFIG = "granite/operations/config/maintenance";
    @Property(value={"granite/operations/config/maintenance"}, label="Config Path", description="Configuration path to the window definitions. This is relative to the base path and must not start with a slash.")
    private static final String PROPERTY_CONFIG = "config";
    @Reference
    private Scheduler scheduler;
    @Reference
    private ResourceResolverFactory rrFactory;
    @Reference
    private MaintenanceTaskManager mtManager;
    @Reference
    private JobManager jobManager;
    @Reference
    private OperationsService operationsService;
    private String resourcePath;
    private String[] resourcePathPrefix;
    private List<MaintenanceWindowImpl> maintenanceWindows;
    private final List<ServiceRegistration> registrations;
    private final BlockingQueue<Boolean> updateQueue;
    private volatile boolean isActive;
    private volatile boolean startupFinished;
    private volatile boolean isLeader;
    private BundleContext bundleContext;
    private ServiceTracker taskTracker;
    private static final String KEY_WINDOW = "window";
    private static final String KEY_JOBS = "jobs";
    private static final String KEY_END = "end";

    public TaskScheduler() {
        this.logger = LoggerFactory.getLogger(this.getClass());
        this.maintenanceWindows = Collections.emptyList();
        this.registrations = new ArrayList<ServiceRegistration>();
        this.updateQueue = new LinkedBlockingQueue<Boolean>();
        this.isActive = false;
        this.startupFinished = false;
        this.isLeader = false;
    }

    /*
     * WARNING - Removed try catching itself - possible behaviour change.
     */
    @Activate
    protected void activate(BundleContext bundleContext, Map<String, Object> props) throws LoginException, InvalidSyntaxException {
        this.bundleContext = bundleContext;
        String basePath = PropertiesUtil.toString((Object)props.get("resourcePath"), (String)"/mnt/overlay");
        String configPath = PropertiesUtil.toString((Object)props.get("config"), (String)"granite/operations/config/maintenance");
        this.resourcePath = basePath + '/' + configPath;
        ResourceResolver resolver = null;
        try {
            resolver = this.rrFactory.getAdministrativeResourceResolver(null);
            String[] paths = resolver.getSearchPath();
            this.resourcePathPrefix = new String[paths.length];
            for (int i = 0; i < this.resourcePathPrefix.length; ++i) {
                this.resourcePathPrefix[i] = paths[i] + configPath;
            }
        }
        finally {
            if (resolver != null) {
                resolver.close();
            }
        }
        this.taskTracker = new ServiceTracker(bundleContext, this.createFilter(bundleContext), new ServiceTrackerCustomizer(){

            public void removedService(ServiceReference reference, Object service) {
                TaskScheduler.this.updateQueue.offer(true);
            }

            public void modifiedService(ServiceReference reference, Object service) {
                TaskScheduler.this.updateQueue.offer(true);
            }

            public Object addingService(ServiceReference reference) {
                TaskScheduler.this.updateQueue.offer(true);
                return reference;
            }
        });
        this.taskTracker.open();
    }

    private Filter createFilter(BundleContext btx) throws InvalidSyntaxException {
        return btx.createFilter(String.format("(&(%s=*)(%s=*)(%s=*))", "granite.maintenance.name", "granite.maintenance.title", "job.topics"));
    }

    @Deactivate
    protected void deactivate() {
        this.stop();
        if (this.taskTracker != null) {
            this.taskTracker.close();
            this.taskTracker = null;
        }
        this.bundleContext = null;
    }

    private void start() {
        this.isActive = true;
        Thread updateThread = new Thread(new Runnable(){

            @Override
            public void run() {
                TaskScheduler.this.processUpdateQueue();
            }
        }, "Adobe Granite Maintenance Scheduler Update Task");
        updateThread.setDaemon(true);
        updateThread.start();
        this.updateQueue.offer(true);
    }

    private void stop() {
        this.isActive = false;
        this.updateQueue.offer(true);
        this.unscheduleWindows();
    }

    public void inform(StartupMode mode, boolean finished) {
        if (finished) {
            this.startupFinished = true;
            this.checkActive();
        }
    }

    public void startupFinished(StartupMode arg0) {
        this.startupFinished = true;
        this.checkActive();
    }

    public void startupProgress(float p) {
    }

    private synchronized void checkActive() {
        if (this.startupFinished && this.isLeader) {
            if (!this.isActive) {
                this.start();
            }
        } else if (this.isActive) {
            this.stop();
        }
    }

    public void handleTopologyEvent(TopologyEvent event) {
        if (event.getType() == TopologyEvent.Type.TOPOLOGY_INIT || event.getType() == TopologyEvent.Type.TOPOLOGY_CHANGED) {
            this.isLeader = event.getNewView().getLocalInstance().isLeader();
            this.checkActive();
        } else if (event.getType() == TopologyEvent.Type.TOPOLOGY_CHANGING) {
            this.isLeader = false;
            this.checkActive();
        }
    }

    private void processUpdateQueue() {
        while (this.isActive) {
            Boolean object = null;
            try {
                object = this.updateQueue.take();
                if (object != null) {
                    this.updateQueue.clear();
                }
            }
            catch (InterruptedException ie) {
                // empty catch block
            }
            if (object == null || !this.isActive) continue;
            this.updateSchedule();
        }
    }

    private synchronized void unscheduleWindows() {
        for (MaintenanceWindowImpl window : this.maintenanceWindows) {
            this.scheduler.unschedule(window.getStartScheduleName());
            this.scheduler.unschedule(window.getEndScheduleName());
        }
        this.maintenanceWindows = Collections.emptyList();
        for (ServiceRegistration reg : this.registrations) {
            reg.unregister();
        }
        this.registrations.clear();
    }

    /*
     * Enabled force condition propagation
     * Lifted jumps to return sites
     */
    public void handleEvent(Event event) {
        if (!this.isActive) return;
        if (event.getTopic().equals("org/apache/sling/event/notification/job/CANCELLED")) {
            String[] log;
            String jobId;
            Job job;
            String topic = (String)event.getProperty("event.job.topic");
            if (topic == null || !topic.startsWith("com/adobe/granite/maintenance/job/") || (job = this.jobManager.getJobById(jobId = (String)event.getProperty("slingevent:eventId"))) == null) return;
            StringBuilder sb = new StringBuilder();
            sb.append("Maintenance task ");
            sb.append(topic.substring("com/adobe/granite/maintenance/job/".length()));
            sb.append(" failed");
            String msg = job.getResultMessage();
            if (msg != null) {
                sb.append(" with message: ");
                sb.append(msg);
            }
            if ((log = job.getProgressLog()) != null && log.length > 0) {
                sb.append("\nFull log:");
                for (String m : log) {
                    sb.append("  ");
                    sb.append(m);
                    sb.append("\n");
                }
            }
            this.logger.error(sb.toString());
            return;
        } else {
            String path = (String)event.getProperty("path");
            if (path == null) return;
            String[] arr$ = this.resourcePathPrefix;
            int len$ = arr$.length;
            int i$ = 0;
            while (i$ < len$) {
                String prefix = arr$[i$];
                if (path.startsWith(prefix)) {
                    this.updateQueue.offer(true);
                    return;
                }
                ++i$;
            }
            return;
        }
    }

    /*
     * WARNING - Removed try catching itself - possible behaviour change.
     */
    private synchronized void updateSchedule() {
        ArrayList<MaintenanceWindowImpl> windows;
        block13 : {
            this.logger.debug("Unscheduling previous maintenance schedule");
            this.unscheduleWindows();
            this.logger.debug("Updating maintenance schedule");
            windows = new ArrayList<MaintenanceWindowImpl>();
            ResourceResolver resolver = null;
            try {
                resolver = this.rrFactory.getAdministrativeResourceResolver(null);
                Resource parent = resolver.getResource(this.resourcePath);
                if (parent == null) break block13;
                for (Resource windowResource : parent.getChildren()) {
                    MaintenanceWindowImpl window = null;
                    try {
                        window = new MaintenanceWindowImpl(windowResource);
                    }
                    catch (IllegalArgumentException iae) {
                        this.logger.error("Unable to read maintenance window definition from " + windowResource.getPath(), (Throwable)iae);
                    }
                    if (window == null) continue;
                    ArrayList<MaintenanceTaskInfo> infos = new ArrayList<MaintenanceTaskInfo>();
                    for (Resource taskResource : windowResource.getChildren()) {
                        String taskName;
                        ValueMap tvm = ResourceUtil.getValueMap((Resource)taskResource);
                        if (!this.operationsService.isEnabled(tvm) || (taskName = (String)tvm.get("granite.maintenance.name", String.class)) == null) continue;
                        MaintenanceTaskInfo info = this.mtManager.getMaintenanceTaskInfo(taskName);
                        if (info != null) {
                            infos.add(info);
                            continue;
                        }
                        this.logger.error("No maintenance task found with name {} for window {}", (Object)taskName, (Object)window.getTitle());
                    }
                    if (infos.size() == 0) {
                        this.logger.info("No maintenance tasks found for window {}", (Object)window.getTitle());
                        continue;
                    }
                    window.setTasks(infos);
                    windows.add(window);
                }
            }
            catch (LoginException le) {
                this.logger.error("Unable to get resource resolver.", (Throwable)le);
            }
            finally {
                if (resolver != null) {
                    resolver.close();
                }
            }
        }
        if (windows.size() == 0) {
            this.logger.error("No maintenance windows found at {}", (Object)this.resourcePath);
        }
        this.maintenanceWindows = windows;
        this.startMaintenanceWindows();
        this.registerHealthChecks();
        this.logger.debug("Maintenance schedule updated");
    }

    private void registerHealthChecks() {
        HashSet<String> configuredTaskNames = new HashSet<String>();
        for (MaintenanceWindowImpl window : this.maintenanceWindows) {
            for (MaintenanceTaskInfo info : window.getMaintenanceTaskInfos()) {
                String taskName = info.getName();
                if (!configuredTaskNames.add(taskName)) continue;
                this.registerHealthCheck(taskName, window.getSchedule());
            }
        }
        for (MaintenanceTaskInfo info : this.mtManager.getMaintenanceTaskInfos()) {
            String taskName;
            if (!info.isMandatory() || !configuredTaskNames.add(taskName = info.getName())) continue;
            this.registerHealthCheck(taskName, null);
        }
    }

    private void registerHealthCheck(String taskName, MaintenanceTaskInfo.TaskSchedule schedule) {
        Hashtable<String, String> regProps = new Hashtable<String, String>();
        regProps.put("hc.name", "Maintenance Task " + taskName);
        regProps.put("hc.mbean.name", "MaintenanceTask" + taskName);
        regProps.put("hc.tags", "system");
        ServiceRegistration reg = this.bundleContext.registerService(HealthCheck.class.getName(), (Object)new MaintenanceTaskHealthCheck(this.mtManager, schedule, taskName), regProps);
        this.registrations.add(reg);
    }

    private void startMaintenanceWindows() {
        for (MaintenanceWindowImpl window : this.maintenanceWindows) {
            this.logger.debug("Starting maintenance window {} from {} to {}", new Object[]{window.getTitle(), window.getStartCronExpression(), window.getEndCronExpression()});
            ArrayList windowJobList = new ArrayList();
            HashMap<String, Serializable> startConfig = new HashMap<String, Serializable>();
            startConfig.put("window", window);
            startConfig.put("end", (Boolean)false);
            startConfig.put("jobs", windowJobList);
            this.scheduler.schedule((Object)this, this.scheduler.EXPR(window.getStartCronExpression()).name(window.getStartScheduleName()).canRunConcurrently(false).onLeaderOnly(true).config(startConfig));
            HashMap<String, Serializable> endConfig = new HashMap<String, Serializable>();
            endConfig.put("window", window);
            endConfig.put("end", (Boolean)true);
            endConfig.put("jobs", windowJobList);
            this.scheduler.schedule((Object)this, this.scheduler.EXPR(window.getEndCronExpression()).name(window.getEndScheduleName()).canRunConcurrently(false).onLeaderOnly(true).config(endConfig));
        }
    }

    public void execute(JobContext context) {
        Map config = context.getConfiguration();
        MaintenanceWindowImpl window = (MaintenanceWindowImpl)config.get("window");
        List jobs = (List)config.get("jobs");
        Boolean isEnd = (Boolean)config.get("end");
        if (isEnd.booleanValue()) {
            for (String jobId : jobs) {
                this.jobManager.stopJobById(jobId);
                Job currentJob = this.jobManager.getJobById(jobId);
                if (currentJob == null || currentJob.getFinishedDate() != null) continue;
                this.jobManager.removeJobById(jobId);
            }
            jobs.clear();
        } else {
            HashMap<String, String> jobProperties = new HashMap<String, String>();
            jobProperties.put("window", window.getTitle());
            for (MaintenanceTaskInfo info : window.getMaintenanceTaskInfos()) {
                Job job = this.jobManager.addJob(info.getTaskTopic(), jobProperties);
                if (job == null) continue;
                jobs.add(job.getId());
            }
        }
    }

    protected void bindScheduler(Scheduler scheduler) {
        this.scheduler = scheduler;
    }

    protected void unbindScheduler(Scheduler scheduler) {
        if (this.scheduler == scheduler) {
            this.scheduler = null;
        }
    }

    protected void bindRrFactory(ResourceResolverFactory resourceResolverFactory) {
        this.rrFactory = resourceResolverFactory;
    }

    protected void unbindRrFactory(ResourceResolverFactory resourceResolverFactory) {
        if (this.rrFactory == resourceResolverFactory) {
            this.rrFactory = null;
        }
    }

    protected void bindMtManager(MaintenanceTaskManager maintenanceTaskManager) {
        this.mtManager = maintenanceTaskManager;
    }

    protected void unbindMtManager(MaintenanceTaskManager maintenanceTaskManager) {
        if (this.mtManager == maintenanceTaskManager) {
            this.mtManager = null;
        }
    }

    protected void bindJobManager(JobManager jobManager) {
        this.jobManager = jobManager;
    }

    protected void unbindJobManager(JobManager jobManager) {
        if (this.jobManager == jobManager) {
            this.jobManager = null;
        }
    }

    protected void bindOperationsService(OperationsService operationsService) {
        this.operationsService = operationsService;
    }

    protected void unbindOperationsService(OperationsService operationsService) {
        if (this.operationsService == operationsService) {
            this.operationsService = null;
        }
    }

}