shibsp/SPConfig.h

   1 /*
   2  *  Copyright 2001-2006 Internet2
   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  * @file shibsp/SPConfig.h
  19  *
  20  * Library configuration
  21  */
  22
  23 #ifndef __shibsp_config_h__
  24 #define __shibsp_config_h__
  25
  26 #include <shibsp/base.h>
  27 #include <xmltooling/PluginManager.h>
  28 #include <xercesc/dom/DOM.hpp>
  29
  30 /**
  31  * @namespace shibsp
  32  * Shibboleth Service Provider Library
  33  */
  34 namespace shibsp {
  35
  36     class SHIBSP_API AccessControl;
  37     class SHIBSP_API Handler;
  38     class SHIBSP_API ListenerService;
  39     class SHIBSP_API RequestMapper;
  40     class SHIBSP_API ServiceProvider;
  41     class SHIBSP_API SessionCache;
  42
  43 #if defined (_MSC_VER)
  44     #pragma warning( push )
  45     #pragma warning( disable : 4250 4251 )
  46 #endif
  47
  48     /**
  49      * Singleton object that manages library startup/shutdown.
  50      */
  51     class SHIBSP_API SPConfig
  52     {
  53     MAKE_NONCOPYABLE(SPConfig);
  54     public:
  55         virtual ~SPConfig() {}
  56
  57         /**
  58          * Returns the global configuration object for the library.
  59          *
  60          * @return reference to the global library configuration object
  61          */
  62         static SPConfig& getConfig();
  63
  64         /**
  65          * Bitmask values representing subsystems of the library.
  66          */
  67         enum components_t {
  68             Listener = 1,
  69             Caching = 2,
  70             Metadata = 4,
  71             Trust = 8,
  72             Credentials = 16,
  73             AAP = 32,
  74             RequestMapping = 64,
  75             OutOfProcess = 128,
  76             InProcess = 256,
  77             Logging = 512
  78         };
  79
  80         /**
  81          * Set a bitmask of subsystems to activate.
  82          *
  83          * @param enabled   bitmask of component constants
  84          */
  85         void setFeatures(unsigned long enabled) {
  86             m_features = enabled;
  87         }
  88
  89         /**
  90          * Test whether a subsystem is enabled.
  91          *
  92          * @param feature   subsystem/component to test
  93          * @return true iff feature is enabled
  94          */
  95         bool isEnabled(components_t feature) {
  96             return (m_features & feature)>0;
  97         }
  98
  99         /**
 100          * Initializes library
 101          *
 102          * Each process using the library MUST call this function exactly once
 103          * before using any library classes.
 104          *
 105          * @param catalog_path  delimited set of schema catalog files to load
 106          * @return true iff initialization was successful
 107          */
 108         virtual bool init(const char* catalog_path)=0;
 109
 110         /**
 111          * Shuts down library
 112          *
 113          * Each process using the library SHOULD call this function exactly once
 114          * before terminating itself.
 115          */
 116         virtual void term()=0;
 117
 118         /**
 119          * Sets the global ServiceProvider instance.
 120          * This method must be externally synchronized with any code that uses the object.
 121          * Any previously set object is destroyed.
 122          *
 123          * @param serviceProvider   new ServiceProvider instance to store
 124          */
 125         void setServiceProvider(ServiceProvider* serviceProvider);
 126
 127         /**
 128          * Returns the global ServiceProvider instance.
 129          *
 130          * @return  global ServiceProvider or NULL
 131          */
 132         ServiceProvider* getServiceProvider() const {
 133             return m_serviceProvider;
 134         }
 135
 136         /**
 137          * Manages factories for AccessControl plugins.
 138          */
 139         xmltooling::PluginManager<AccessControl,const xercesc::DOMElement*> AccessControlManager;
 140
 141         /**
 142          * Manages factories for Handler plugins that implement AssertionConsumerService functionality.
 143          */
 144         xmltooling::PluginManager<Handler,const xercesc::DOMElement*> AssertionConsumerServiceManager;
 145
 146         /**
 147          * Manages factories for Handler plugins that implement customized functionality.
 148          */
 149         xmltooling::PluginManager<Handler,const xercesc::DOMElement*> HandlerManager;
 150
 151         /**
 152          * Manages factories for ListenerService plugins.
 153          */
 154         xmltooling::PluginManager<ListenerService,const xercesc::DOMElement*> ListenerServiceManager;
 155
 156         /**
 157          * Manages factories for Handler plugins that implement ManageNameIDService functionality.
 158          */
 159         xmltooling::PluginManager<Handler,const xercesc::DOMElement*> ManageNameIDServiceManager;
 160
 161         /**
 162          * Manages factories for RequestMapper plugins.
 163          */
 164         xmltooling::PluginManager<RequestMapper,const xercesc::DOMElement*> RequestMapperManager;
 165
 166         /**
 167          * Manages factories for ServiceProvider plugins.
 168          */
 169         xmltooling::PluginManager<ServiceProvider,const xercesc::DOMElement*> ServiceProviderManager;
 170
 171         /**
 172          * Manages factories for SessionCache plugins.
 173          */
 174         xmltooling::PluginManager<SessionCache,const xercesc::DOMElement*> SessionCacheManager;
 175
 176         /**
 177          * Manages factories for Handler plugins that implement SessionInitiator functionality.
 178          */
 179         xmltooling::PluginManager<Handler,const xercesc::DOMElement*> SessionInitiatorManager;
 180
 181         /**
 182          * Manages factories for Handler plugins that implement SingleLogoutService functionality.
 183          */
 184         xmltooling::PluginManager<Handler,const xercesc::DOMElement*> SingleLogoutServiceManager;
 185
 186     protected:
 187         SPConfig() : m_serviceProvider(NULL) {}
 188
 189         /** Global ServiceProvider instance. */
 190         ServiceProvider* m_serviceProvider;
 191
 192     private:
 193         unsigned long m_features;
 194     };
 195
 196 #if defined (_MSC_VER)
 197     #pragma warning( pop )
 198 #endif
 199
 200 };
 201
 202 #endif /* __shibsp_config_h__ */