001    package railo.runtime.config;
002    
003    import java.io.IOException;
004    import java.net.URL;
005    import java.util.Enumeration;
006    import java.util.Map;
007    
008    import javax.servlet.ServletConfig;
009    import javax.servlet.ServletContext;
010    import javax.servlet.http.HttpServletRequest;
011    import javax.servlet.http.HttpServletResponse;
012    
013    import org.apache.commons.collections.map.ReferenceMap;
014    import org.xml.sax.SAXException;
015    
016    import railo.commons.io.SystemUtil;
017    import railo.commons.io.log.Log;
018    import railo.commons.io.log.LogAndSource;
019    import railo.commons.io.log.LogAndSourceImpl;
020    import railo.commons.io.log.LogConsole;
021    import railo.commons.io.res.Resource;
022    import railo.commons.io.res.ResourceProvider;
023    import railo.commons.io.res.ResourcesImpl;
024    import railo.commons.lang.ClassException;
025    import railo.commons.lang.StringUtil;
026    import railo.commons.lock.KeyLock;
027    import railo.runtime.CFMLFactoryImpl;
028    import railo.runtime.Mapping;
029    import railo.runtime.MappingImpl;
030    import railo.runtime.Page;
031    import railo.runtime.PageContext;
032    import railo.runtime.PageSourceImpl;
033    import railo.runtime.cfx.CFXTagPool;
034    import railo.runtime.compiler.CFMLCompilerImpl;
035    import railo.runtime.debug.DebuggerPool;
036    import railo.runtime.engine.ThreadQueueImpl;
037    import railo.runtime.exp.ExpressionException;
038    import railo.runtime.exp.PageException;
039    import railo.runtime.exp.SecurityException;
040    import railo.runtime.gateway.GatewayEngineImpl;
041    import railo.runtime.gateway.GatewayEntry;
042    import railo.runtime.lock.LockManager;
043    import railo.runtime.lock.LockManagerImpl;
044    import railo.runtime.monitor.ActionMonitorCollector;
045    import railo.runtime.monitor.IntervallMonitor;
046    import railo.runtime.monitor.RequestMonitor;
047    import railo.runtime.net.http.ReqRspUtil;
048    import railo.runtime.security.SecurityManager;
049    import railo.runtime.security.SecurityManagerImpl;
050    import railo.runtime.tag.TagHandlerPool;
051    import railo.runtime.type.scope.Cluster;
052    import railo.runtime.writer.CFMLWriter;
053    import railo.runtime.writer.CFMLWriterImpl;
054    import railo.runtime.writer.CFMLWriterWS;
055    import railo.runtime.writer.CFMLWriterWSPref;
056    import railo.transformer.library.function.FunctionLibException;
057    import railo.transformer.library.tag.TagLibException;
058    
059    /**
060     * Web Context
061     */
062    public final class ConfigWebImpl extends ConfigImpl implements ServletConfig, ConfigWeb {
063        
064        private ServletConfig config;
065        private ConfigServerImpl configServer;
066        private SecurityManager securityManager;
067        private static final LockManager lockManager= LockManagerImpl.getInstance(false);
068        private Resource rootDir;
069        private CFMLCompilerImpl compiler=new CFMLCompilerImpl();
070        private Page baseComponentPage;
071            private MappingImpl serverTagMapping;
072            private MappingImpl serverFunctionMapping;
073            private KeyLock<String> contextLock;
074            private GatewayEngineImpl gatewayEngine;
075        private LogAndSource gatewayLogger=null;//new LogAndSourceImpl(LogConsole.getInstance(Log.LEVEL_INFO),"");private DebuggerPool debuggerPool;
076        private DebuggerPool debuggerPool;
077            
078        
079    
080        //private File deployDirectory;
081    
082        /**
083         * constructor of the class
084         * @param configServer
085         * @param config
086         * @param configDir
087         * @param configFile
088         * @param cloneServer 
089         */
090        protected ConfigWebImpl(CFMLFactoryImpl factory,ConfigServerImpl configServer, ServletConfig config, Resource configDir, Resource configFile) {
091            super(factory,configDir, configFile,configServer.getTLDs(),configServer.getFLDs());
092            this.configServer=configServer;
093            this.config=config;
094            factory.setConfig(this);
095            ResourceProvider frp = ResourcesImpl.getFileResourceProvider();
096            
097            this.rootDir=frp.getResource(ReqRspUtil.getRootPath(config.getServletContext()));
098            
099            
100            // Fix for tomcat
101            if(this.rootDir.getName().equals(".") || this.rootDir.getName().equals(".."))
102                    this.rootDir=this.rootDir.getParentResource();
103        }
104        
105        public void reset() {
106            super.reset();
107            tagHandlerPool.reset();
108            contextLock=null;
109            baseComponentPage=null;
110        }
111        
112        /* *
113         * Constructor of the class, used for configserver dummy instance
114         * @param factory
115         * @param configServer
116         * @param configx
117         * @param configDir
118         * @param configFile
119         * /
120        protected ConfigWebImpl(CFMLFactoryImpl factory,ConfigServerImpl configServer, Resource configDir, Resource configFile,Resource rootDir) {
121            super(factory,configDir, configFile,configServer.getTLDs(),configServer.getFLDs());
122            this.configServer=configServer;
123            factory.setConfig(this);
124            
125            this.rootDir=rootDir;
126            
127            // Fix for tomcat
128            if(this.rootDir.getName().equals(".") || this.rootDir.getName().equals(".."))
129                    this.rootDir=this.rootDir.getParentResource();
130        }*/
131        
132        
133    
134        @Override
135        public String getServletName() {
136            return config.getServletName();
137        }
138    
139        @Override
140        public ServletContext getServletContext() {
141            return config.getServletContext();
142        }
143    
144        @Override
145        public String getInitParameter(String name) {
146            return config.getInitParameter(name);
147        }
148    
149        @Override
150        public Enumeration getInitParameterNames() {
151            return config.getInitParameterNames();
152        }
153    
154        protected ConfigServerImpl getConfigServerImpl() {
155            return configServer;
156        }
157        
158        @Override
159        public ConfigServer getConfigServer(String password) throws ExpressionException {
160            if(!configServer.hasPassword())
161                throw new ExpressionException("Cannot access, no password is defined");
162            if(!configServer.getPassword().equalsIgnoreCase(password))
163                throw new ExpressionException("No access, password is invalid");
164            return configServer;
165        }
166        
167        public String getServerId() {
168            return configServer.getId();
169        }
170    
171        public String getServerSecurityKey() {
172            return configServer.getSecurityKey();
173        }
174        
175        public Resource getServerConfigDir() {
176            return configServer.getConfigDir();
177        }
178        
179    
180        /**
181         * @return Returns the accessor.
182         */
183        public SecurityManager getSecurityManager() {
184            return securityManager;
185        }
186    
187        /**
188         * @param securityManager The accessor to set.
189         */
190        protected void setSecurityManager(SecurityManager securityManager) {
191            ((SecurityManagerImpl)securityManager).setRootDirectory(getRootDirectory());
192            this.securityManager = securityManager;
193        }
194        
195        @Override
196        public CFXTagPool getCFXTagPool() throws SecurityException {
197            if(securityManager.getAccess(SecurityManager.TYPE_CFX_USAGE)==SecurityManager.VALUE_YES) return super.getCFXTagPool();
198            throw new SecurityException("no access to cfx functionality", "disabled by security settings");
199        }
200    
201        /**
202         * @return Returns the rootDir.
203         */
204        public Resource getRootDirectory() {
205            return rootDir;
206        }
207    
208        @Override
209        public String getUpdateType() {
210            return configServer.getUpdateType();
211        }
212    
213        @Override
214        public URL getUpdateLocation() {
215            return configServer.getUpdateLocation();
216        }
217    
218        @Override
219        public LockManager getLockManager() {
220            return lockManager;
221        }
222    
223            /**
224             * @return the compiler
225             */
226            public CFMLCompilerImpl getCompiler() {
227                    return compiler;
228            }
229            
230             public Page getBaseComponentPage(PageContext pc) throws PageException {
231                    if(baseComponentPage==null) {
232                        baseComponentPage=((PageSourceImpl)getBaseComponentPageSource(pc)).loadPage(pc);
233                                    
234                    }
235                    return baseComponentPage;
236                }
237                public void resetBaseComponentPage() {
238                    baseComponentPage=null;
239                }
240                
241    
242    
243                    
244    
245                public Mapping getServerTagMapping() {
246                    if(serverTagMapping==null){
247                            serverTagMapping=getConfigServerImpl().tagMapping.cloneReadOnly(this);
248                    }
249                            return serverTagMapping;
250                    }
251                public Mapping getServerFunctionMapping() {
252                    if(serverFunctionMapping==null){
253                            serverFunctionMapping=getConfigServerImpl().functionMapping.cloneReadOnly(this);
254                    }
255                            return serverFunctionMapping;
256                    }
257                private Map<String,Mapping> applicationMappings=new ReferenceMap();
258                    private TagHandlerPool tagHandlerPool=new TagHandlerPool(this);
259                    public Mapping getApplicationMapping(String virtual, String physical) {
260                            return getApplicationMapping(virtual, physical, null);
261                    }
262                    
263                    public Mapping getApplicationMapping(String virtual, String physical, String archive) {
264                            String key=virtual.toLowerCase()+physical.toLowerCase();
265                            Mapping m= applicationMappings.get(key);
266                            if(m==null){
267                                    m=new MappingImpl(this,
268                                            virtual,
269                                            physical,
270                                            archive,ConfigImpl.INSPECT_UNDEFINED,true,false,false,false,true,false,null
271                                            );
272                                    applicationMappings.put(key, m);
273                            }
274                            return m;
275                    }
276    
277                    public String getLabel() {
278                            String hash=getHash();
279                            String label=hash;
280                            Map<String, String> labels = configServer.getLabels();
281                            if(labels!=null) {
282                                    String l = labels.get(hash);
283                                    if(!StringUtil.isEmpty(l)) {
284                                            label=l;
285                                    }
286                            }
287                            return label;
288                    }
289                    
290                    public String getHash() {
291                            return SystemUtil.hash(getServletContext());
292                    }
293    
294                    public KeyLock<String> getContextLock() {
295                            if(contextLock==null) {
296                                    contextLock=new KeyLock<String>();
297                            }
298                            return contextLock;
299                    }
300    
301    
302                    protected void setGatewayEntries(Map<String, GatewayEntry> gatewayEntries) {
303                            try {
304                                    getGatewayEngine().addEntries(this,gatewayEntries);
305                            } catch (Exception e) {
306                                    e.printStackTrace();
307                            }       
308                    }
309                    public GatewayEngineImpl getGatewayEngine() {
310                            if(gatewayEngine==null){
311                                    gatewayEngine=new GatewayEngineImpl(this);
312                            }
313                            return gatewayEngine;
314                    }
315                    public void setGatewayEngine(GatewayEngineImpl gatewayEngine) {
316                            this.gatewayEngine=gatewayEngine;
317                    }
318    
319                public LogAndSource getGatewayLogger() {
320                    if(gatewayLogger==null)gatewayLogger=new LogAndSourceImpl(LogConsole.getInstance(this,Log.LEVEL_ERROR),"");
321                            return gatewayLogger;
322                }
323    
324    
325                public void setGatewayLogger(LogAndSource gatewayLogger) {
326                    this.gatewayLogger=gatewayLogger;
327                }
328    
329                    public TagHandlerPool getTagHandlerPool() {
330                            return tagHandlerPool;
331                    }
332    
333                    public DebuggerPool getDebuggerPool() {
334                            if(debuggerPool==null){
335                                    Resource dir = getConfigDir().getRealResource("debugger");
336                                    dir.mkdirs();
337                                    debuggerPool=new DebuggerPool(dir);
338                            }
339                            return debuggerPool;
340                    }
341                    
342    
343                    public ThreadQueueImpl getThreadQueue() {
344                            return configServer.getThreadQueue();
345                    }
346    
347                    @Override
348                    public int getLoginDelay() {
349                            return configServer.getLoginDelay();
350                    }
351    
352                    @Override
353                    public boolean getLoginCaptcha() {
354                            return configServer.getLoginCaptcha();
355                    }
356                    
357                    @Override
358                    public Resource getSecurityDirectory(){
359                            return configServer.getSecurityDirectory();
360                    }
361                    
362                    @Override
363                    public boolean isMonitoringEnabled(){
364                            return configServer.isMonitoringEnabled();
365                    }
366                    
367    
368                    
369                    public RequestMonitor[] getRequestMonitors(){
370                            return configServer.getRequestMonitors();
371                    }
372                    
373                    public RequestMonitor getRequestMonitor(String name) throws PageException{
374                            return configServer.getRequestMonitor(name);
375                    }
376                    
377                    public IntervallMonitor[] getIntervallMonitors(){
378                            return configServer.getIntervallMonitors();
379                    }
380    
381                    public IntervallMonitor getIntervallMonitor(String name) throws PageException{
382                            return configServer.getIntervallMonitor(name);
383                    }
384                    
385                    @Override
386                    public void checkPermGenSpace(boolean check) {
387                            configServer.checkPermGenSpace(check);
388                    }
389    
390                    @Override
391                    public Cluster createClusterScope() throws PageException {
392                            return configServer.createClusterScope();
393                    }
394    
395                    @Override
396                    public boolean hasServerPassword() {
397                            return configServer.hasPassword();
398                    }
399                    
400                    public void setPassword(boolean server, String passwordOld, String passwordNew) 
401                            throws PageException, SAXException, ClassException, IOException, TagLibException, FunctionLibException {
402                    ConfigImpl config=server?configServer:this;
403                        
404                        if(!config.hasPassword()) { 
405                            config.setPassword(passwordNew);
406                            
407                            ConfigWebAdmin admin = ConfigWebAdmin.newInstance(config,passwordNew);
408                            admin.setPassword(passwordNew);
409                            admin.store();
410                        }
411                        else {
412                            ConfigWebUtil.checkGeneralWriteAccess(config,passwordOld);
413                            ConfigWebAdmin admin = ConfigWebAdmin.newInstance(config,passwordOld);
414                            admin.setPassword(passwordNew);
415                            admin.store();
416                        }
417                    }
418    
419                    @Override
420                    public Resource getConfigServerDir() {
421                            return configServer.getConfigDir();
422                    }
423    
424                    public Map<String, String> getAllLabels() {
425                            return configServer.getLabels();
426                    }
427    
428                    @Override
429                    public boolean allowRequestTimeout() {
430                            return configServer.allowRequestTimeout();
431                    }
432                    
433                    public CFMLWriter getCFMLWriter(HttpServletRequest req, HttpServletResponse rsp) {
434                            // FUTURE  move interface CFMLWriter to Loader and load dynaicly from railo-web.xml
435                    if(writerType==CFML_WRITER_WS)
436                        return new CFMLWriterWS             (req,rsp,-1,false,closeConnection(),isShowVersion(),contentLength(),allowCompression());
437                    else if(writerType==CFML_WRITER_REFULAR) 
438                        return new CFMLWriterImpl                   (req,rsp,-1,false,closeConnection(),isShowVersion(),contentLength(),allowCompression());
439                    else
440                        return new CFMLWriterWSPref (req,rsp,-1,false,closeConnection(),isShowVersion(),contentLength(),allowCompression());
441                }
442    
443                    
444                    public ActionMonitorCollector getActionMonitorCollector() {
445                            return configServer.getActionMonitorCollector();
446                    }
447    
448                    @Override
449                    public boolean getFullNullSupport() {
450                            return configServer.getFullNullSupport();
451                    }
452                    public boolean hasIndividualSecurityManager() {
453                            return configServer.hasIndividualSecurityManager(getId());
454                }
455    }