configmgr/source/backend/backendfactory.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: backendfactory.cxx,v $
  10  * $Revision: 1.12 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_configmgr.hxx"
  33
  34 #include "backendfactory.hxx"
  35
  36 #ifndef CONFIGMGR_API_FACTORY_HXX_
  37 #include "confapifactory.hxx"
  38 #endif
  39 #include "bootstrapcontext.hxx"
  40 #include "bootstrap.hxx"
  41 #include "backendaccess.hxx"
  42 #include "serviceinfohelper.hxx"
  43 #include "wrapexception.hxx"
  44
  45
  46 #include <com/sun/star/configuration/CannotLoadConfigurationException.hpp>
  47 #include <com/sun/star/configuration/backend/XBackend.hpp>
  48 #include <com/sun/star/configuration/backend/XMultiLayerStratum.hpp>
  49
  50 namespace configmgr
  51 {
  52 // -------------------------------------------------------------------------
  53     namespace backend
  54     {
  55 // -------------------------------------------------------------------------
  56         namespace uno = ::com::sun::star::uno;
  57         namespace lang = ::com::sun::star::lang;
  58         namespace backenduno = ::com::sun::star::configuration::backend;
  59 // -------------------------------------------------------------------------
  60 const sal_Char k_DefaultBackendWrapper[] = "com.sun.star.comp.configuration.backend.SingleBackendAdapter";
  61 const sal_Char k_DefaultBackendService[] = "com.sun.star.comp.configuration.backend.LocalSingleBackend";
  62
  63 // -------------------------------------------------------------------------
  64 const sal_Char k_DefaultBackendServiceAndImplName[]         = K_DefaultBackendServiceAndImplName ;
  65
  66 // -------------------------------------------------------------------------
  67 const sal_Char k_GenericBackendServiceAndImplName[]         = "com.sun.star.configuration.backend.Backend" ;
  68
  69 // -------------------------------------------------------------------------
  70 static sal_Char const * const k_BackendServiceNames [] =
  71 {
  72     k_DefaultBackendServiceAndImplName,
  73     k_GenericBackendServiceAndImplName,
  74     0
  75 };
  76 // -------------------------------------------------------------------------
  77 static const ServiceRegistrationInfo k_DefaultBackendServiceInfo =
  78 {
  79     k_DefaultBackendServiceAndImplName,
  80     k_BackendServiceNames
  81 };
  82 // -------------------------------------------------------------------------
  83 static const ServiceRegistrationInfo k_GenericBackendServiceInfo =
  84 {
  85     k_GenericBackendServiceAndImplName,
  86     k_BackendServiceNames + 1
  87 };
  88 // -------------------------------------------------------------------------
  89 static const SingletonRegistrationInfo k_DefaultBackendSingletonInfo =
  90 {
  91     K_DefaultBackendSingletonName,
  92     k_DefaultBackendServiceAndImplName,
  93     k_DefaultBackendServiceAndImplName,
  94     & k_GenericBackendServiceInfo
  95 };
  96 // -------------------------------------------------------------------------
  97 // -------------------------------------------------------------------------
  98 const SingletonRegistrationInfo * getDefaultBackendSingletonInfo()
  99 {
 100     return & k_DefaultBackendSingletonInfo;
 101 }
 102 // -------------------------------------------------------------------------
 103
 104 const ServiceRegistrationInfo   * getDefaultBackendServiceInfo()
 105 {
 106     return & k_DefaultBackendServiceInfo;
 107 }
 108 // -------------------------------------------------------------------------
 109 // -------------------------------------------------------------------------
 110
 111 uno::Reference<uno::XInterface> SAL_CALL
 112     getDefaultBackendSingleton( com::sun::star::uno::Reference< com::sun::star::uno::XComponentContext > const& xContext )
 113 {
 114     OSL_ENSURE( xContext.is(), "ERROR: NULL context has no singletons" );
 115
 116     UnoContextTunnel aTunnel;
 117     aTunnel.passthru( xContext );
 118
 119     uno::Reference<uno::XInterface> xResult;
 120
 121     if (xContext.is())
 122     try
 123     {
 124         xContext->getValueByName(SINGLETON(K_DefaultBackendSingletonName))
 125             >>= xResult;
 126     }
 127     catch (uno::Exception & )
 128     {
 129         // to do: really use the tunneled failure when that is set properly
 130         if ( aTunnel.recoverFailure(true).hasValue() )
 131         {
 132             // have a failure, but can't recover it
 133             // -> try to regenerate
 134             instantiateDefaultBackend(xContext);
 135
 136             OSL_ENSURE(false, "Cannot recreate configuration backend instantiation failure - using generic error");
 137         }
 138         // cannot recover any failure
 139         throw;
 140     }
 141
 142     return xResult;
 143 }
 144 // -------------------------------------------------------------------------
 145
 146 // -------------------------------------------------------------------------
 147 // -------------------------------------------------------------------------
 148
 149 static
 150 uno::Sequence< uno::Any > createInitArgs(ContextReader const & _aContext)
 151 {
 152     OSL_ASSERT(_aContext.hasBootstrapContext());
 153     uno::Sequence< uno::Any > aResult( 1 );
 154     aResult[0] <<= _aContext.getBootstrapContext();
 155     return aResult;
 156 }
 157 // -------------------------------------------------------------------------
 158
 159 static
 160 inline
 161 uno::Reference< uno::XInterface > createService(ContextReader const & _aCtx, uno::Sequence< uno::Any > const & _aInitArgs, rtl::OUString const & _aSvc)
 162 {
 163     uno::Reference< lang::XMultiComponentFactory > xFactory = _aCtx.getServiceManager();
 164     OSL_ENSURE(xFactory.is(),"ERROR: ComponentContext has no service manager\n");
 165     if (!xFactory.is()) throw uno::RuntimeException( rtl::OUString::createFromAscii("ERROR: ComponentContext has no service manager\n"), NULL );
 166     return xFactory->createInstanceWithArgumentsAndContext( _aSvc, _aInitArgs, _aCtx.getBaseContext());
 167 }
 168 // -------------------------------------------------------------------------
 169
 170 static
 171 uno::Reference< backenduno::XBackend > wrapSingleBackend(ContextReader const & _aSettings, uno::Sequence< uno::Any > const & _aInitArgs, uno::Reference< backenduno::XMultiLayerStratum > const & _xWrappedBackend)
 172 {
 173     OSL_ASSERT(_aSettings.hasUnoBackendWrapper() || _aSettings.hasBootstrapContext());
 174
 175     rtl::OUString aWrapperSvc = _aSettings.hasUnoBackendWrapper() ?
 176                                 _aSettings.getUnoBackendWrapper() :
 177                                 rtl::OUString::createFromAscii(k_DefaultBackendWrapper);
 178
 179     OSL_ENSURE (aWrapperSvc.getLength(), "ERROR: No wrapper service for wrapped configuration");
 180     OSL_ENSURE (_xWrappedBackend.is(), "ERROR: No backend to wrap for wrapped configuration");
 181
 182     sal_Int32 const nBaseArgsCount = _aInitArgs.getLength();
 183     uno::Sequence< uno::Any > aExtendedArgs( _aInitArgs );
 184     aExtendedArgs.realloc( nBaseArgsCount + 1 );
 185     aExtendedArgs[nBaseArgsCount] <<= _xWrappedBackend;
 186
 187     return uno::Reference< backenduno::XBackend >::query( createService(_aSettings,aExtendedArgs,aWrapperSvc) );
 188 }
 189 // -------------------------------------------------------------------------
 190
 191 static
 192 uno::Reference< backenduno::XBackend > createOfflineBackend(ContextReader const & _aSettings, uno::Sequence< uno::Any > const & _aInitArgs)
 193 {
 194     OSL_ASSERT(_aSettings.hasUnoBackendWrapper() || _aSettings.hasBootstrapContext());
 195
 196     uno::Reference< backenduno::XBackend > xResult;
 197     if ( _aSettings.hasUnoBackendWrapper() )
 198     {
 199         rtl::OUString const aWrapperSvc = _aSettings.getUnoBackendWrapper();
 200
 201         xResult = uno::Reference< backenduno::XBackend >::query( createService(_aSettings,_aInitArgs,aWrapperSvc) );
 202     }
 203
 204     return xResult;
 205 }
 206 // -------------------------------------------------------------------------
 207
 208 static
 209 uno::Reference< uno::XInterface > createRealBackend(ContextReader const & _aSettings, uno::Sequence< uno::Any > const & _aInitArgs)
 210 {
 211     OSL_ASSERT(_aSettings.hasUnoBackendService() || _aSettings.hasBootstrapContext());
 212
 213     rtl::OUString const aBackendServiceName = _aSettings.hasUnoBackendService() ?
 214                                         _aSettings.getUnoBackendService() :
 215                                         rtl::OUString::createFromAscii(k_DefaultBackendService);
 216
 217     uno::Reference< uno::XInterface > xResult =
 218         createService(_aSettings,_aInitArgs,aBackendServiceName);
 219
 220     return xResult;
 221 }
 222 // -------------------------------------------------------------------------
 223
 224 static
 225 uno::Reference< backenduno::XBackend > createOnlineBackend(ContextReader const & _aSettings, uno::Sequence< uno::Any > const & _aInitArgs)
 226 {
 227     OSL_ENSURE( _aSettings.isUnoBackend(), "ERROR - BackendFactory: For legacy backends use createSessionBackend()");
 228
 229     uno::Reference< backenduno::XBackend > xResult;
 230
 231     uno::Reference< uno::XInterface > xRealBackend = createRealBackend(_aSettings,_aInitArgs);
 232
 233     if (_aSettings.hasUnoBackendWrapper())
 234     {
 235         // try wrapping a single backend
 236         uno::Reference< backenduno::XMultiLayerStratum > xSingleRealBackend( xRealBackend, uno::UNO_QUERY);
 237         if (xSingleRealBackend.is())
 238             xResult = wrapSingleBackend(_aSettings,_aInitArgs,xSingleRealBackend);
 239
 240         // if we don't have one, try using it as unwrapped backend
 241         else
 242             xResult.set(xRealBackend, uno::UNO_QUERY);
 243     }
 244     else
 245     {
 246          // look for a direct implementation of XBackend
 247         xResult.set(xRealBackend, uno::UNO_QUERY);
 248         if (!xResult.is())
 249         {
 250             // try the default wrapper if we only have a single backend
 251             uno::Reference< backenduno::XMultiLayerStratum > xSingleRealBackend( xRealBackend, uno::UNO_QUERY);
 252             if (xSingleRealBackend.is())
 253                 xResult = wrapSingleBackend(_aSettings,_aInitArgs,xSingleRealBackend);
 254
 255             else
 256                 OSL_ENSURE( !xRealBackend.is(), "Configuration Backend implements no known backend interface" );
 257         }
 258     }
 259
 260     return xResult;
 261 }
 262 // -------------------------------------------------------------------------
 263
 264 static uno::Reference< backenduno::XBackend > createUnoBackend(com::sun::star::uno::Reference< com::sun::star::uno::XComponentContext > const& _xCtx)
 265 {
 266     ContextReader aSettings(_xCtx);
 267     OSL_ENSURE( aSettings.isUnoBackend(), "ERROR - BackendFactory: Legacy backends are not supported any more");
 268
 269     uno::Sequence< uno::Any > aArguments = createInitArgs(aSettings);
 270
 271     sal_Bool bOffline = aSettings.hasOfflineSetting() ? aSettings.getOfflineSetting() : !aSettings.hasUnoBackendService();
 272
 273     uno::Reference< backenduno::XBackend > xResult;
 274
 275     if (!bOffline)
 276         xResult = createOnlineBackend (aSettings,aArguments);
 277
 278     if (!xResult.is())
 279         xResult = createOfflineBackend(aSettings,aArguments);
 280
 281     return xResult;
 282 }
 283 // -------------------------------------------------------------------------
 284 // to do: tunnel and raise fully typed exception information (and use it in the get..Singleton wrappers)
 285     #define TUNNEL_ALL_EXCEPTIONS()     \
 286         WRAP_CONFIGBACKEND_CREATION_EXCEPTIONS1( UnoContextTunnel::tunnelFailure, true )
 287
 288 // -------------------------------------------------------------------------
 289
 290 uno::Reference<uno::XInterface> SAL_CALL instantiateDefaultBackend( com::sun::star::uno::Reference< com::sun::star::uno::XComponentContext > const& xTargetContext )
 291 {
 292     com::sun::star::uno::Reference< com::sun::star::uno::XComponentContext > xContext = UnoContextTunnel::recoverContext(xTargetContext);
 293
 294     try
 295     {
 296         return uno::Reference< uno::XInterface >( createUnoBackend(xContext), uno::UNO_QUERY );
 297     }
 298     TUNNEL_ALL_EXCEPTIONS()
 299
 300     OSL_ASSERT(!"unreached");
 301     return NULL;
 302 }
 303 // -------------------------------------------------------------------------
 304
 305 uno::Reference< backenduno::XBackend > BackendFactory::getUnoBackend()
 306 {
 307     return uno::Reference< backenduno::XBackend >::query( getDefaultBackendSingleton(m_xCtx) );
 308 }
 309 // -------------------------------------------------------------------------
 310
 311 rtl::Reference<IMergedDataProvider> BackendFactory::createBackend()
 312 {
 313     rtl::Reference< IMergedDataProvider > xBackend;
 314
 315     uno::Reference< backenduno::XBackend > xBackendService = this->getUnoBackend();
 316
 317     if (xBackendService.is())
 318         xBackend = new BackendAccess(xBackendService, m_xCtx);
 319
 320     return xBackend;
 321 }
 322 // -------------------------------------------------------------------------
 323
 324 BackendFactory BackendFactory::instance(com::sun::star::uno::Reference< com::sun::star::uno::XComponentContext > const & _xCtx)
 325 {
 326     return BackendFactory(_xCtx);
 327 }
 328
 329 //-----------------------------------------------------------------------------
 330     } // namespace
 331 //-----------------------------------------------------------------------------
 332 } // namespace