Moved java src to apache license.
[java-idp.git] / src / edu / internet2 / middleware / shibboleth / serviceprovider / ServiceProviderContext.java
1 /*
2  * Copyright [2005] [University Corporation for Advanced Internet Development, Inc.]
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
17 /*
18  * ServiceProviderContext.java
19  * 
20  * There is one ServiceProviderContext per Service Provider.
21  * Other objects and collections of objects are referenced through it.
22  * 
23  * An object of type ServiceProviderContext must be created and
24  * shared among the Shibboleth classes in the same Service Provider.
25  * The default implimentation is for the object to be created during
26  * the static initialization of the class and accessed through the
27  * static getInstance() factory method.
28  * 
29  * Any change to this strategy can be propagated to all other classes
30  * just by changing the getInstance() method implementation to use 
31  * a different factory or lookup service.
32  */
33 package edu.internet2.middleware.shibboleth.serviceprovider;
34
35 import org.opensaml.NoSuchProviderException;
36 import org.opensaml.ReplayCache;
37 import org.opensaml.ReplayCacheFactory;
38
39 /**
40  * Unique object through which all Service Provider objects and collections
41  * are found. Obtain a reference to this object by calling the static
42  * getInstance() method.
43  * 
44  * @author Howard Gilbert
45  *
46  */
47 public class ServiceProviderContext {
48         
49         /*
50          * This static object provides the default implimentation of the 
51          * ServiceProviderContext singleton object. However, the getInstance
52          * Factory actually determines the particular instance used.
53          * 
54          * Warning:
55          * 
56          * Some of the following fields may have an initialization
57          * expression as in "Foo x = new Foo()".
58          * The "Foo" class in turn may have a constructor or its own
59          * static and non-static initialization statements. If anywhere
60          * in this cascade of initialization triggered directly or 
61          * indirectly by creating this first new object of type
62          * ServiceProviderContext() there is some code that calls
63          * back to getServiceProviderContext() then it will get back
64          * a null from that call. This is because the SPContext
65          * variable is not filled in with a reference to the object 
66          * until it is constructed, and we are still in the middle of
67          * constructing it.  
68          */
69         private static ServiceProviderContext targetContext = new ServiceProviderContext();
70         
71         /*
72          * The fatalErrors flag provides a global reference where Service Provider
73          * components can know that we are totally hosed and cannot proceed. When
74          * set, this tells all servlets right up front to generate error messages
75          * and apologize.
76          */
77         private boolean fatalErrors = false; 
78         
79         
80         
81         /**
82          * <p>Static Factory method to return the ServiceProviderContext.
83          * </p><p>
84          * The default implmementation is to use a static field. 
85          * However, in other environments you may wish to replace this
86          * with an object managed by J2EE or by Spring. If so, create
87          * the object someplace else and change this factory to locate
88          * it with LDAP, an external context, Spring, or whatever.
89          * </p>
90          * @return Returns the ServiceProviderContext object.
91          */
92         public static ServiceProviderContext getInstance() {
93                 return targetContext;
94         }
95         
96         /**
97          * The ServiceProviderConfig object holds all information from
98          * the configuration file and the other sources of information
99          * and metadata to which it refers.
100          */
101         private ServiceProviderConfig serviceProviderConfig = null;
102         
103         
104         
105         /*
106          * <p>Manager for the collection (and Cache) of Session Objects
107          * </p><p>
108          * All access to and creation/deletion of Sessions occurs through
109          * this object. This could be a wiring point later if someone
110          * wanted to load and configure the Session Manager in Spring.
111          */
112         private SessionManager sessionManager = null;
113
114         private ReplayCache replayCache = null;
115         
116         private ThreadLocal requestContext = new ThreadLocal();
117                 public void setRequestContext(RequestTracker trk) {
118                     requestContext.set(trk);
119                 }
120                 public RequestTracker getRequestContext() {
121                     return (RequestTracker) requestContext.get();
122                 }
123
124         /**
125          * Constructor currently made private to force use of getInstance()
126          */
127         private ServiceProviderContext() {
128         }
129         
130         
131         
132         // property accessor methods
133
134         public synchronized SessionManager getSessionManager() {
135             // deferred allocation, since sessionManger needs a reference
136             // back to context.
137             if (sessionManager==null)
138                     sessionManager = new SessionManager();
139                 return sessionManager;
140         }
141
142     // TODO: Make this pluggable / configurable
143     public synchronized ReplayCache getReplayCache() {
144         if (replayCache == null) {
145             try {
146                 replayCache = ReplayCacheFactory.getInstance();
147             }
148             catch (NoSuchProviderException e) {
149             }
150         }
151         return replayCache;
152     }
153     
154         public ServiceProviderConfig getServiceProviderConfig() {
155                 return serviceProviderConfig;
156         }
157         public void setServiceProviderConfig(
158                         ServiceProviderConfig serviceProviderConfig) {
159                 this.serviceProviderConfig = serviceProviderConfig;
160         }
161         public boolean isFatalErrors() {
162                 return fatalErrors;
163         }
164         public void setFatalErrors(boolean fatalErrors) {
165                 this.fatalErrors = fatalErrors;
166         }
167         
168 }