| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| package org.apache.sling.slingbucks.server; |
| |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.Calendar; |
| import java.util.HashSet; |
| import java.util.List; |
| import java.util.Set; |
| |
| import javax.jcr.Item; |
| import javax.jcr.Node; |
| import javax.jcr.Property; |
| import javax.jcr.Repository; |
| import javax.jcr.RepositoryException; |
| import javax.jcr.Session; |
| import javax.jcr.observation.Event; |
| import javax.jcr.observation.EventIterator; |
| import javax.jcr.observation.EventListener; |
| import javax.jcr.observation.ObservationManager; |
| |
| import org.apache.felix.scr.annotations.Component; |
| import org.apache.felix.scr.annotations.Properties; |
| import org.apache.felix.scr.annotations.Reference; |
| import org.apache.felix.scr.annotations.Service; |
| import org.apache.sling.jcr.api.SlingRepository; |
| import org.osgi.service.component.ComponentContext; |
| import org.slf4j.Logger; |
| import org.slf4j.LoggerFactory; |
| |
| /** Move confirmed orders under CONFIRMED_ORDERS_PATH, |
| * by observing changes under ORDERS_PATH |
| * |
| * To execute our run() method periodically to check |
| * if orders are ready to move, we use the Sling scheduler |
| * service with the whiteboard pattern: registering this |
| * class as a Runnable service and adding a property to |
| * define the running schedule is sufficient to execute |
| * the run() method regularly. |
| */ |
| @Component |
| @Service(value=Runnable.class) |
| @Properties({ |
| @org.apache.felix.scr.annotations.Property(name="scheduler.period", longValue=1), |
| @org.apache.felix.scr.annotations.Property(name="scheduler.concurrent", boolValue=false) |
| }) |
| public class ConfirmedOrdersObserver implements EventListener, Runnable { |
| private Logger log = LoggerFactory.getLogger(getClass()); |
| |
| @Reference |
| private SlingRepository repository; |
| |
| private Session session; |
| private ObservationManager observationManager; |
| |
| private Set<String> changedPropertyPaths = new HashSet<String>(); |
| private static final long WAIT_AFTER_LAST_CHANGE_MSEC = 5000; |
| |
| protected void activate(ComponentContext context) throws Exception { |
| session = repository.loginAdministrative(null); |
| |
| // Listen for changes to our orders |
| if (repository.getDescriptor(Repository.OPTION_OBSERVATION_SUPPORTED).equals("true")) { |
| observationManager = session.getWorkspace().getObservationManager(); |
| final String[] types = { "nt:unstructured" }; |
| final boolean isDeep = true; |
| final boolean noLocal = true; |
| final String path = SlingbucksConstants.ORDERS_PATH; |
| observationManager.addEventListener(this, Event.PROPERTY_CHANGED | Event.PROPERTY_ADDED, path, isDeep, null, types, noLocal); |
| log.info("Observing property changes to {} nodes under {}", Arrays.asList(types), path); |
| } |
| |
| } |
| |
| protected void deactivate(ComponentContext componentContext) throws RepositoryException { |
| if(observationManager != null) { |
| observationManager.removeEventListener(this); |
| } |
| if (session != null) { |
| session.logout(); |
| session = null; |
| } |
| } |
| |
| public void onEvent(EventIterator it) { |
| while (it.hasNext()) { |
| // Just accumulate the changed paths - we'll do the actual work in |
| // a separate non-event method, as this should return quickly. |
| try { |
| final String path = it.nextEvent().getPath(); |
| if(path.endsWith(SlingbucksConstants.CONFIRMED_ORDER_PROPERTY_NAME)) { |
| synchronized (changedPropertyPaths) { |
| log.debug("onEvent: property {} changed", path); |
| changedPropertyPaths.add(path); |
| } |
| } |
| } catch(Exception e) { |
| log.warn(e.getClass().getName() + " in onEvent", e); |
| } |
| } |
| } |
| |
| /** Meant to be called often (every second maybe) by the Sling scheduler */ |
| public void run() { |
| if(changedPropertyPaths.isEmpty()) { |
| return; |
| } |
| |
| final List<String> paths = new ArrayList<String>(); |
| final List<String> toRetry = new ArrayList<String>(); |
| synchronized (changedPropertyPaths) { |
| paths.addAll(changedPropertyPaths); |
| changedPropertyPaths.clear(); |
| } |
| |
| try { |
| while(!paths.isEmpty()) { |
| final String path = paths.remove(0); |
| if(session.itemExists(path)) { |
| final Item it = session.getItem(path); |
| if(!it.isNode()) { |
| final Property p = (Property)it; |
| final Node n = p.getParent(); |
| if(!n.hasProperty(SlingbucksConstants.LAST_MODIFIED_PROPERTY_NAME)) { |
| log.debug("Node {} doesn't have property {}, ignored", n.getPath(), SlingbucksConstants.LAST_MODIFIED_PROPERTY_NAME); |
| } else { |
| Calendar lastMod = n.getProperty(SlingbucksConstants.LAST_MODIFIED_PROPERTY_NAME).getDate(); |
| if(System.currentTimeMillis() - lastMod.getTime().getTime() < WAIT_AFTER_LAST_CHANGE_MSEC) { |
| log.debug("Node {} modified more recently than {} msec, ignored", n.getPath(), WAIT_AFTER_LAST_CHANGE_MSEC); |
| toRetry.add(path); |
| } else { |
| final String targetPath = SlingbucksConstants.CONFIRMED_ORDERS_PATH + "/" + n.getName(); |
| session.getWorkspace().move(n.getPath(), targetPath); |
| log.info("Confirmed order node {} moved to {}", n.getPath(), targetPath); |
| } |
| } |
| } |
| } |
| } |
| } catch(Exception e){ |
| log.error("Exception in run()", e); |
| } finally { |
| // Re-add any paths that we didn't process |
| synchronized (changedPropertyPaths) { |
| changedPropertyPaths.addAll(paths); |
| changedPropertyPaths.addAll(toRetry); |
| } |
| } |
| } |
| } |