KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > outerj > daisy > publisher > serverimpl > resolving > PublisherRequestResolver


1 /*
2  * Copyright 2004 Outerthought bvba and Schaubroeck nv
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */

16 package org.outerj.daisy.publisher.serverimpl.resolving;
17
18 import org.outerj.daisy.repository.Document;
19 import org.outerj.daisy.repository.Repository;
20 import org.outerj.daisy.repository.Version;
21 import org.outerj.daisy.repository.RepositoryException;
22 import org.outerj.daisy.publisher.PublisherException;
23 import org.outerj.daisy.publisher.serverimpl.CommonPublisher;
24 import org.outerj.daisy.publisher.serverimpl.requestmodel.PublisherRequest;
25 import org.outerj.daisy.xmlutil.LocalSAXParserFactory;
26 import org.apache.avalon.framework.logger.Logger;
27 import org.apache.xmlbeans.XmlOptions;
28 import org.outerx.daisy.x10Publisher.PublisherRequestDocument;
29 import org.xml.sax.SAXException JavaDoc;
30
31 import java.util.Map JavaDoc;
32 import java.io.*;
33
34 import EDU.oswego.cs.dl.util.concurrent.ConcurrentReaderHashMap;
35
36 /**
37  * Decides which publisher request to use for a certain document.
38  */

39 public class PublisherRequestResolver {
40     private File pubRequestsRoot;
41     private Repository repository;
42     private CommonPublisher commonPublisher;
43     private Logger logger;
44     private Map JavaDoc cache = new ConcurrentReaderHashMap();
45     private final String JavaDoc resolveDefinitionMutex = "ResolveDefinitionMutex";
46     private final String JavaDoc publisherRequestMutex = "PublisherRequestMutex";
47     private ResolveDefinition defaultResolveDefinition;
48     private Map JavaDoc defaultPubReqs = new ConcurrentReaderHashMap();
49
50     public PublisherRequestResolver(File pubRequestsRoot, Repository repository, CommonPublisher commonPublisher, Logger logger) {
51         this.pubRequestsRoot = pubRequestsRoot;
52         this.repository = repository;
53         this.commonPublisher = commonPublisher;
54         this.logger = logger;
55     }
56
57     /**
58      * Caller is responsible for closing the returned input stream!
59      */

60     public PublisherRequest lookupPublisherRequest(String JavaDoc pubReqSetName, Document document, Version version)
61             throws PublisherException, RepositoryException, SAXException JavaDoc {
62         ResolveDefinition resolveDefinition = getResolveDefinition(pubReqSetName);
63         String JavaDoc pubReqName = resolveDefinition.resolve(document, version);
64         if (pubReqName == null)
65             throw new PublisherException("No publisher request found in set \"" + pubReqSetName + "\" for document " + document.getVariantKey());
66
67         if (pubReqSetName.equals("default")) {
68             return getDefaultPubReq(pubReqName);
69         } else {
70             File pubReqFile = new File(new File(pubRequestsRoot, pubReqSetName), pubReqName);
71             return getPublisherRequest(pubReqFile);
72         }
73     }
74
75     private ResolveDefinition getResolveDefinition(String JavaDoc pubReqSetName) throws PublisherException {
76         if (pubReqSetName.equals("default"))
77             return getDefaultResolveDefinition();
78
79         ResolveDefinition resolveDefinition = (ResolveDefinition)getFromCache(pubReqSetName);
80         if (resolveDefinition == null) {
81             synchronized(resolveDefinitionMutex) {
82                 resolveDefinition = (ResolveDefinition)getFromCache(pubReqSetName);
83                 if (resolveDefinition == null) {
84                     ResolveDefinitionBuilder builder = new ResolveDefinitionBuilder(repository, logger);
85                     File mappingFile = new File(new File(pubRequestsRoot, pubReqSetName), "mapping.xml");
86                     long timestamp = mappingFile.lastModified();
87                     resolveDefinition = builder.build(mappingFile, pubReqSetName);
88                     putInCache(pubReqSetName, timestamp, mappingFile, resolveDefinition);
89                 }
90             }
91         }
92         return resolveDefinition;
93     }
94
95     private PublisherRequest getPublisherRequest(File pubReqFile) throws PublisherException, RepositoryException, SAXException JavaDoc {
96         String JavaDoc cacheKey = pubReqFile.getAbsolutePath();
97         PublisherRequest publisherRequest = (PublisherRequest)getFromCache(cacheKey);
98         if (publisherRequest == null) {
99             synchronized(publisherRequestMutex) {
100                 publisherRequest = (PublisherRequest)getFromCache(cacheKey);
101                 if (publisherRequest == null) {
102                     long timestamp = pubReqFile.lastModified();
103                     PublisherRequestDocument publisherRequestDocument;
104                     try {
105                         XmlOptions xmlOptions = new XmlOptions().setLoadUseXMLReader(LocalSAXParserFactory.newXmlReader());
106                         publisherRequestDocument = PublisherRequestDocument.Factory.parse(pubReqFile, xmlOptions);
107                     } catch (Exception JavaDoc e) {
108                         throw new PublisherException("Error parsing publisher request from " + pubReqFile.getAbsolutePath(), e);
109                     }
110
111                     publisherRequest = commonPublisher.buildPublisherRequest(publisherRequestDocument);
112                     putInCache(cacheKey, timestamp, pubReqFile, publisherRequest);
113                 }
114             }
115         }
116         return publisherRequest;
117     }
118
119     private synchronized Object JavaDoc getFromCache(String JavaDoc cacheKey) {
120         CacheEntry cacheEntry = (CacheEntry)cache.get(cacheKey);
121         if (cacheEntry == null) {
122             return null;
123         } else if (cacheEntry.timestamp != cacheEntry.file.lastModified()) {
124             cache.remove(cacheKey);
125             return null;
126         } else {
127             return cacheEntry.object;
128         }
129     }
130
131     private synchronized void putInCache(String JavaDoc cacheKey, long timestamp, File file, Object JavaDoc object) {
132         CacheEntry cacheEntry = new CacheEntry();
133         cacheEntry.timestamp = timestamp;
134         cacheEntry.file = file;
135         cacheEntry.object = object;
136         cache.put(cacheKey, cacheEntry);
137     }
138
139     private static class CacheEntry {
140         long timestamp;
141         File file;
142         Object JavaDoc object;
143     }
144
145     private ResolveDefinition getDefaultResolveDefinition() throws PublisherException {
146         if (this.defaultResolveDefinition != null)
147             return this.defaultResolveDefinition;
148
149         synchronized(this) {
150             if (this.defaultResolveDefinition != null)
151                 return this.defaultResolveDefinition;
152
153             InputStream is = null;
154             try {
155                 is = this.getClass().getClassLoader().getResourceAsStream("org/outerj/daisy/publisher/serverimpl/resolving/default/mapping.xml");
156                 ResolveDefinitionBuilder builder = new ResolveDefinitionBuilder(repository, logger);
157                 this.defaultResolveDefinition = builder.build(is, "default");
158                 return this.defaultResolveDefinition;
159             } finally {
160                 if (is != null)
161                     try { is.close(); } catch (Exception JavaDoc e) { logger.error("Error closing InputStream in finally.", e); }
162             }
163         }
164     }
165
166     private PublisherRequest getDefaultPubReq(String JavaDoc name) throws PublisherException, RepositoryException, SAXException JavaDoc {
167         PublisherRequest publisherRequest = (PublisherRequest)defaultPubReqs.get(name);
168         if (publisherRequest != null)
169             return publisherRequest;
170
171         synchronized (this) {
172             publisherRequest = (PublisherRequest)defaultPubReqs.get(name);
173             if (publisherRequest != null)
174                 return publisherRequest;
175
176             InputStream is = null;
177             try {
178                 String JavaDoc path = "org/outerj/daisy/publisher/serverimpl/resolving/default/" + name;
179                 is = this.getClass().getClassLoader().getResourceAsStream(path);
180
181                 PublisherRequestDocument publisherRequestDocument;
182                 try {
183                     XmlOptions xmlOptions = new XmlOptions().setLoadUseXMLReader(LocalSAXParserFactory.newXmlReader());
184                     publisherRequestDocument = PublisherRequestDocument.Factory.parse(is, xmlOptions);
185                 } catch (Exception JavaDoc e) {
186                     throw new PublisherException("Error parsing publisher request from resource " + path, e);
187                 }
188
189                 publisherRequest = commonPublisher.buildPublisherRequest(publisherRequestDocument);
190                 defaultPubReqs.put(name, publisherRequest);
191                 return publisherRequest;
192             } finally {
193                 if (is != null)
194                     try { is.close(); } catch (Exception JavaDoc e) { logger.error("Error closing InputStream in finally.", e); }
195             }
196         }
197     }
198
199 }
200
Popular Tags