1 /* 2 * Licensed to the Apache Software Foundation (ASF) under one 3 * or more contributor license agreements. See the NOTICE file 4 * distributed with this work for additional information 5 * regarding copyright ownership. The ASF licenses this file 6 * to you under the Apache License, Version 2.0 (the 7 * "License"); you may not use this file except in compliance 8 * with the License. You may obtain a copy of the License at 9 * 10 * http://www.apache.org/licenses/LICENSE-2.0 11 * 12 * Unless required by applicable law or agreed to in writing, 13 * software distributed under the License is distributed on an 14 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 15 * KIND, either express or implied. See the License for the 16 * specific language governing permissions and limitations 17 * under the License. 18 */ 19 20 package org.apache.myfaces.orchestra; 21 22 /** 23 * A place to define all the configuration constants that can be used to 24 * configure parts of Orchestra core. 25 * 26 * @since 1.1 27 */ 28 public final class CoreConfig 29 { 30 private static final String BASE = CoreConfig.class.getName(); 31 32 /** 33 * Value "org.apache.myfaces.orchestra.CoreConfig:SERIALIZE_REQUESTS". 34 * <p> 35 * Controls whether two threads are prevented from accessing the same 36 * ConversationContext concurrently, or not. This is generally a bad idea as it 37 * can lead to ugly race conditions, so it is TRUE by default. 38 * <p> 39 * It is possible for multiple requests associated with the same http session to be 40 * received concurrently. By default, a servlet engine simply processes all requests 41 * concurrently in different threads. However that can cause all sorts of unexpected 42 * problems with objects in scopes that are visible to both threads (session-scoped 43 * and conversation-scoped objects). 44 * <p> 45 * When enabled, this option will block the thread for any request which will 46 * access the same Orchestra ConversationContext as a thread that is already 47 * running, and release it only when the earlier request has completed. This protects 48 * all orchestra conversation-scoped objects from concurrent access, but 49 * <i>does not</i> protect any session-scoped objects. 50 * <p> 51 * When using Orchestra, it is recommended that session-scoped objects are avoided 52 * conversation-scoped beans used instead. If there is no session-scoped data in 53 * use by an application then it is safe to allow concurrent requests to the 54 * same http session. If you do wish to protect normal session-scoped objects as 55 * well, then the standard solution is to write a filter that uses standard java 56 * synchronisation on a session-scoped object, taking the lock on request entry 57 * and releasing it on request exit. 58 * <p> 59 * Note that the expression "serialize requests" as used here means requests are 60 * processed serially, ie one after the other rather than concurrently. This has 61 * nothing to do with java.io.Serializable. 62 */ 63 public static final String SERIALIZE_REQUESTS = BASE + ":SERIALIZE_REQUESTS"; 64 65 /** 66 * Value "org.apache.myfaces.orchestra.CoreConfig:CLEANUP_CONNECTIONS". 67 * <p> 68 * Controls whether Orchestra should monitor the set of JDBC connections borrowed 69 * during a request, and clean up any that are still open at the end of the request. 70 * <p> 71 * Orchestra provides a special DataSource wrapper that can be configured for any 72 * datasource used by the application. The datasource simply wraps all real Connection 73 * objects it returns in a proxy, and keeps track of them. At the end of each request, 74 * any connections borrowed by this thread but not returned can be returned 75 * automatically. See ConnectionManagerDataSource for more details. 76 * <p> 77 * If this special DataSource is not configured, then checking for unreleased 78 * connections is harmless, and always finds nothing. Therefore this option is 79 * enabled by default. 80 */ 81 public static final String CLEANUP_CONNECTIONS = BASE + ":CLEANUP_CONNECTIONS"; 82 83 /** 84 * Value "org.apache.myfaces.orchestra.CoreConfig:CONVERSATION_MESSAGER". 85 * <p> 86 * Controls what class is used to present Orchestra-related error messages to 87 * the user. When not specified, the default implementation for the current 88 * FrameworkAdapter (eg JsfFrameworkAdapter) is used. 89 * <p> 90 * See class ConversationMessager for further details. 91 */ 92 public static final String CONVERSATION_MESSAGER = BASE + ":CONVERSATION_MESSAGER"; 93 }