connectivity/source/cpool/ZPoolCollection.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include "ZPoolCollection.hxx"
  21 #include "ZDriverWrapper.hxx"
  22 #include "ZConnectionPool.hxx"
  23 #include <com/sun/star/configuration/theDefaultProvider.hpp>
  24 #include <com/sun/star/container/XHierarchicalNameAccess.hpp>
  25 #include <com/sun/star/beans/NamedValue.hpp>
  26 #include <com/sun/star/beans/PropertyValue.hpp>
  27 #include <com/sun/star/frame/Desktop.hpp>
  28 #include <com/sun/star/reflection/ProxyFactory.hpp>
  29 #include <com/sun/star/sdbc/DriverManager.hpp>
  30 #include <comphelper/processfactory.hxx>
  31 #include <cppuhelper/supportsservice.hxx>
  32 #include <com/sun/star/beans/XPropertySet.hpp>
  33 #include <osl/diagnose.h>
  34 #include <sal/log.hxx>
  35 #include <tools/diagnose_ex.h>
  36
  37 using namespace ::com::sun::star::uno;
  38 using namespace ::com::sun::star::lang;
  39 using namespace ::com::sun::star::sdbc;
  40 using namespace ::com::sun::star::beans;
  41 using namespace ::com::sun::star::container;
  42 using namespace ::com::sun::star::reflection;
  43 using namespace ::osl;
  44 using namespace connectivity;
  45
  46
  47 static OUString getConnectionPoolNodeName()
  48 {
  49     return OUString(  "org.openoffice.Office.DataAccess/ConnectionPool" );
  50 }
  51
  52 static OUString getEnablePoolingNodeName()
  53 {
  54     return OUString(  "EnablePooling" );
  55 }
  56
  57 static OUString getDriverNameNodeName()
  58 {
  59     return OUString(  "DriverName" );
  60 }
  61
  62 static OUString getDriverSettingsNodeName()
  63 {
  64     return OUString(  "DriverSettings" );
  65 }
  66
  67 static OUString getEnableNodeName()
  68 {
  69     return OUString(  "Enable" );
  70 }
  71
  72
  73 OPoolCollection::OPoolCollection(const Reference< XComponentContext >& _rxContext)
  74     :m_xContext(_rxContext)
  75 {
  76     // bootstrap all objects supporting the .sdb.Driver service
  77     m_xManager = DriverManager::create( m_xContext );
  78
  79     m_xProxyFactory = ProxyFactory::create( m_xContext );
  80
  81     Reference<XPropertySet> xProp(getConfigPoolRoot(),UNO_QUERY);
  82     if ( xProp.is() )
  83         xProp->addPropertyChangeListener(getEnablePoolingNodeName(),this);
  84     // attach as desktop listener to know when we have to release our pools
  85     osl_atomic_increment( &m_refCount );
  86     {
  87
  88         m_xDesktop = css::frame::Desktop::create( m_xContext );
  89         m_xDesktop->addTerminateListener(this);
  90
  91     }
  92     osl_atomic_decrement( &m_refCount );
  93 }
  94
  95 OPoolCollection::~OPoolCollection()
  96 {
  97     clearConnectionPools(false);
  98 }
  99
 100 Reference< XConnection > SAL_CALL OPoolCollection::getConnection( const OUString& _rURL )
 101 {
 102     return getConnectionWithInfo(_rURL,Sequence< PropertyValue >());
 103 }
 104
 105 Reference< XConnection > SAL_CALL OPoolCollection::getConnectionWithInfo( const OUString& _rURL, const Sequence< PropertyValue >& _rInfo )
 106 {
 107     MutexGuard aGuard(m_aMutex);
 108     Reference< XConnection > xConnection;
 109     Reference< XDriver > xDriver;
 110     Reference< XInterface > xDriverNode;
 111     OUString sImplName;
 112     if(isPoolingEnabledByUrl(_rURL,xDriver,sImplName,xDriverNode) && xDriver.is())
 113     {
 114         OConnectionPool* pConnectionPool = getConnectionPool(sImplName,xDriver,xDriverNode);
 115
 116         if(pConnectionPool)
 117             xConnection = pConnectionPool->getConnectionWithInfo(_rURL,_rInfo);
 118     }
 119     else if(xDriver.is())
 120         xConnection = xDriver->connect(_rURL,_rInfo);
 121
 122     return xConnection;
 123 }
 124
 125 void SAL_CALL OPoolCollection::setLoginTimeout( sal_Int32 seconds )
 126 {
 127     MutexGuard aGuard(m_aMutex);
 128     m_xManager->setLoginTimeout(seconds);
 129 }
 130
 131 sal_Int32 SAL_CALL OPoolCollection::getLoginTimeout(  )
 132 {
 133     MutexGuard aGuard(m_aMutex);
 134     return m_xManager->getLoginTimeout();
 135 }
 136
 137 OUString SAL_CALL OPoolCollection::getImplementationName(  )
 138 {
 139     return getImplementationName_Static();
 140 }
 141
 142 sal_Bool SAL_CALL OPoolCollection::supportsService( const OUString& _rServiceName )
 143 {
 144     return cppu::supportsService(this, _rServiceName);
 145 }
 146
 147
 148 Sequence< OUString > SAL_CALL OPoolCollection::getSupportedServiceNames(  )
 149 {
 150     return getSupportedServiceNames_Static();
 151 }
 152
 153 //---------------------------------------OPoolCollection----------------------------------
 154 Reference< XInterface > OPoolCollection::CreateInstance(const Reference< XMultiServiceFactory >& _rxFactory)
 155 {
 156     return static_cast<XDriverManager*>(new OPoolCollection(comphelper::getComponentContext(_rxFactory)));
 157 }
 158
 159
 160 OUString OPoolCollection::getImplementationName_Static(  )
 161 {
 162     return OUString("com.sun.star.sdbc.OConnectionPool");
 163 }
 164
 165
 166 Sequence< OUString > OPoolCollection::getSupportedServiceNames_Static(  )
 167 {
 168     Sequence< OUString > aSupported { "com.sun.star.sdbc.ConnectionPool" };
 169     return aSupported;
 170 }
 171
 172 Reference< XDriver > SAL_CALL OPoolCollection::getDriverByURL( const OUString& _rURL )
 173 {
 174     // returns the original driver when no connection pooling is enabled else it returns the proxy
 175     MutexGuard aGuard(m_aMutex);
 176
 177     Reference< XDriver > xDriver;
 178     Reference< XInterface > xDriverNode;
 179     OUString sImplName;
 180     if(isPoolingEnabledByUrl(_rURL,xDriver,sImplName,xDriverNode))
 181     {
 182         Reference< XDriver > xExistentProxy;
 183         // look if we already have a proxy for this driver
 184         for (const auto& [rxDriver, rxDriverRef] : m_aDriverProxies)
 185         {
 186             // hold the proxy alive as long as we're in this loop round
 187             xExistentProxy = rxDriverRef;
 188
 189             if (xExistentProxy.is() && (rxDriver.get() == xDriver.get()))
 190                 // already created a proxy for this
 191                 break;
 192         }
 193         if (xExistentProxy.is())
 194         {
 195             xDriver = xExistentProxy;
 196         }
 197         else
 198         {   // create a new proxy for the driver
 199             // this allows us to control the connections created by it
 200             Reference< XAggregation > xDriverProxy = m_xProxyFactory->createProxy(xDriver.get());
 201             OSL_ENSURE(xDriverProxy.is(), "OConnectionPool::getDriverByURL: invalid proxy returned by the proxy factory!");
 202
 203             OConnectionPool* pConnectionPool = getConnectionPool(sImplName,xDriver,xDriverNode);
 204             xDriver = new ODriverWrapper(xDriverProxy, pConnectionPool);
 205         }
 206     }
 207
 208     return xDriver;
 209 }
 210
 211 bool OPoolCollection::isDriverPoolingEnabled(const OUString& _sDriverImplName,
 212                                                  Reference< XInterface >& _rxDriverNode)
 213 {
 214     bool bEnabled = false;
 215     Reference<XInterface> xConnectionPoolRoot = getConfigPoolRoot();
 216     // then look for which of them settings are stored in the configuration
 217     Reference< XNameAccess > xDirectAccess(openNode(getDriverSettingsNodeName(),xConnectionPoolRoot),UNO_QUERY);
 218
 219     if(xDirectAccess.is())
 220     {
 221         Sequence< OUString > aDriverKeys = xDirectAccess->getElementNames();
 222         const OUString* pDriverKeys = aDriverKeys.getConstArray();
 223         const OUString* pDriverKeysEnd = pDriverKeys + aDriverKeys.getLength();
 224         for (;pDriverKeys != pDriverKeysEnd; ++pDriverKeys)
 225         {
 226             // the name of the driver in this round
 227             if(_sDriverImplName == *pDriverKeys)
 228             {
 229                 _rxDriverNode = openNode(*pDriverKeys,xDirectAccess);
 230                 if(_rxDriverNode.is())
 231                     getNodeValue(getEnableNodeName(),_rxDriverNode) >>= bEnabled;
 232                 break;
 233             }
 234         }
 235     }
 236     return bEnabled;
 237 }
 238
 239 bool OPoolCollection::isPoolingEnabled()
 240 {
 241     // the config node where all pooling relevant info are stored under
 242     Reference<XInterface> xConnectionPoolRoot = getConfigPoolRoot();
 243
 244     // the global "enabled" flag
 245     bool bEnabled = false;
 246     if(xConnectionPoolRoot.is())
 247         getNodeValue(getEnablePoolingNodeName(),xConnectionPoolRoot) >>= bEnabled;
 248     return bEnabled;
 249 }
 250
 251 Reference<XInterface> const & OPoolCollection::getConfigPoolRoot()
 252 {
 253     if(!m_xConfigNode.is())
 254         m_xConfigNode = createWithProvider(
 255             css::configuration::theDefaultProvider::get(m_xContext),
 256             getConnectionPoolNodeName());
 257     return m_xConfigNode;
 258 }
 259
 260 bool OPoolCollection::isPoolingEnabledByUrl(const OUString& _sUrl,
 261                                                 Reference< XDriver >& _rxDriver,
 262                                                 OUString& _rsImplName,
 263                                                 Reference< XInterface >& _rxDriverNode)
 264 {
 265     bool bEnabled = false;
 266     _rxDriver = m_xManager->getDriverByURL(_sUrl);
 267     if (_rxDriver.is() && isPoolingEnabled())
 268     {
 269         Reference< XServiceInfo > xSerivceInfo(_rxDriver,UNO_QUERY);
 270         OSL_ENSURE(xSerivceInfo.is(),"Each driver should have a XServiceInfo interface!");
 271
 272         if(xSerivceInfo.is())
 273         {
 274             // look for the implementation name of the driver
 275             _rsImplName = xSerivceInfo->getImplementationName();
 276             bEnabled = isDriverPoolingEnabled(_rsImplName,_rxDriverNode);
 277         }
 278     }
 279     return bEnabled;
 280 }
 281
 282 void OPoolCollection::clearConnectionPools(bool _bDispose)
 283 {
 284     for(auto& rEntry : m_aPools)
 285     {
 286         rEntry.second->clear(_bDispose);
 287     }
 288     m_aPools.clear();
 289 }
 290
 291 OConnectionPool* OPoolCollection::getConnectionPool(const OUString& _sImplName,
 292                                                     const Reference< XDriver >& _xDriver,
 293                                                     const Reference< XInterface >& _xDriverNode)
 294 {
 295     OConnectionPool *pRet = nullptr;
 296     OConnectionPools::const_iterator aFind = m_aPools.find(_sImplName);
 297     if (aFind != m_aPools.end())
 298         pRet = aFind->second.get();
 299     else if (_xDriver.is() && _xDriverNode.is())
 300     {
 301         Reference<XPropertySet> xProp(_xDriverNode,UNO_QUERY);
 302         if(xProp.is())
 303             xProp->addPropertyChangeListener(getEnableNodeName(),this);
 304         OConnectionPool* pConnectionPool = new OConnectionPool(_xDriver,_xDriverNode,m_xProxyFactory);
 305         aFind = m_aPools.emplace(_sImplName,pConnectionPool).first;
 306         pRet = aFind->second.get();
 307     }
 308
 309     OSL_ENSURE(pRet, "Could not query DriverManager from ConnectionPool!");
 310
 311     return pRet;
 312 }
 313
 314 Reference< XInterface > OPoolCollection::createWithProvider(const Reference< XMultiServiceFactory >& _rxConfProvider,
 315                             const OUString& _rPath)
 316 {
 317     OSL_ASSERT(_rxConfProvider.is());
 318     Sequence< Any > args(1);
 319     args[0] <<= NamedValue( "nodepath", makeAny(_rPath));
 320     Reference< XInterface > xInterface(
 321         _rxConfProvider->createInstanceWithArguments(
 322             "com.sun.star.configuration.ConfigurationAccess",
 323             args));
 324     OSL_ENSURE(
 325         xInterface.is(),
 326         "::createWithProvider: could not create the node access!");
 327     return xInterface;
 328 }
 329
 330 Reference<XInterface> OPoolCollection::openNode(const OUString& _rPath,const Reference<XInterface>& _xTreeNode) throw()
 331 {
 332     Reference< XHierarchicalNameAccess > xHierarchyAccess(_xTreeNode, UNO_QUERY);
 333     Reference< XNameAccess > xDirectAccess(_xTreeNode, UNO_QUERY);
 334     Reference< XInterface > xNode;
 335
 336     try
 337     {
 338         if (xDirectAccess.is() && xDirectAccess->hasByName(_rPath))
 339         {
 340             xNode.set(xDirectAccess->getByName(_rPath), css::uno::UNO_QUERY);
 341             SAL_WARN_IF(
 342                 !xNode.is(), "connectivity.cpool",
 343                 "OConfigurationNode::openNode: could not open the node!");
 344         }
 345         else if (xHierarchyAccess.is())
 346         {
 347             xNode.set(
 348                 xHierarchyAccess->getByHierarchicalName(_rPath),
 349                 css::uno::UNO_QUERY);
 350             SAL_WARN_IF(
 351                 !xNode.is(), "connectivity.cpool",
 352                 "OConfigurationNode::openNode: could not open the node!");
 353         }
 354
 355     }
 356     catch(const NoSuchElementException&)
 357     {
 358         SAL_WARN("connectivity.cpool", "::openNode: there is no element named " <<
 359                  _rPath << "!");
 360     }
 361     catch(Exception&)
 362     {
 363         css::uno::Any ex( cppu::getCaughtException() );
 364         SAL_WARN("connectivity.cpool", "OConfigurationNode::openNode: caught an exception while retrieving the node! " << exceptionToString(ex));
 365     }
 366     return xNode;
 367 }
 368
 369 Any OPoolCollection::getNodeValue(const OUString& _rPath,const Reference<XInterface>& _xTreeNode) throw()
 370 {
 371     Reference< XHierarchicalNameAccess > xHierarchyAccess(_xTreeNode, UNO_QUERY);
 372     Reference< XNameAccess > xDirectAccess(_xTreeNode, UNO_QUERY);
 373     Any aReturn;
 374     try
 375     {
 376         if (xDirectAccess.is() && xDirectAccess->hasByName(_rPath) )
 377         {
 378             aReturn = xDirectAccess->getByName(_rPath);
 379         }
 380         else if (xHierarchyAccess.is())
 381         {
 382             aReturn = xHierarchyAccess->getByHierarchicalName(_rPath);
 383         }
 384     }
 385     catch(NoSuchElementException& e)
 386     {
 387         SAL_WARN("connectivity.cpool", e );
 388     }
 389     return aReturn;
 390 }
 391
 392 void SAL_CALL OPoolCollection::queryTermination( const EventObject& /*Event*/ )
 393 {
 394 }
 395
 396 void SAL_CALL OPoolCollection::notifyTermination( const EventObject& /*Event*/ )
 397 {
 398     clearDesktop();
 399 }
 400
 401 void SAL_CALL OPoolCollection::disposing( const EventObject& Source )
 402 {
 403     MutexGuard aGuard(m_aMutex);
 404     if ( m_xDesktop == Source.Source )
 405     {
 406         clearDesktop();
 407     }
 408     else
 409     {
 410         try
 411         {
 412             Reference<XPropertySet> xProp(Source.Source,UNO_QUERY);
 413             if(Source.Source == m_xConfigNode)
 414             {
 415                 if ( xProp.is() )
 416                     xProp->removePropertyChangeListener(getEnablePoolingNodeName(),this);
 417                 m_xConfigNode.clear();
 418             }
 419             else if ( xProp.is() )
 420                 xProp->removePropertyChangeListener(getEnableNodeName(),this);
 421         }
 422         catch(const Exception&)
 423         {
 424             SAL_WARN("connectivity.cpool", "Exception caught");
 425         }
 426     }
 427 }
 428
 429 void SAL_CALL OPoolCollection::propertyChange( const css::beans::PropertyChangeEvent& evt )
 430 {
 431     MutexGuard aGuard(m_aMutex);
 432     if(evt.Source == m_xConfigNode)
 433     {
 434         bool bEnabled = true;
 435         evt.NewValue >>= bEnabled;
 436         if(!bEnabled )
 437         {
 438             m_aDriverProxies.clear();
 439             m_aDriverProxies = MapDriver2DriverRef();
 440             clearConnectionPools(false);
 441         }
 442     }
 443     else if(evt.Source.is())
 444     {
 445         bool bEnabled = true;
 446         evt.NewValue >>= bEnabled;
 447         if(!bEnabled)
 448         {
 449             OUString sThisDriverName;
 450             getNodeValue(getDriverNameNodeName(),evt.Source) >>= sThisDriverName;
 451             // 1st release the driver
 452             // look if we already have a proxy for this driver
 453             MapDriver2DriverRef::iterator aLookup = m_aDriverProxies.begin();
 454             while(  aLookup != m_aDriverProxies.end())
 455             {
 456                 MapDriver2DriverRef::iterator aFind = aLookup;
 457                 Reference<XServiceInfo> xInfo(aLookup->first,UNO_QUERY);
 458                 ++aLookup;
 459                 if(xInfo.is() && xInfo->getImplementationName() == sThisDriverName)
 460                     m_aDriverProxies.erase(aFind);
 461             }
 462
 463             // 2nd clear the connectionpool
 464             OConnectionPools::iterator aFind = m_aPools.find(sThisDriverName);
 465             if(aFind != m_aPools.end())
 466             {
 467                 aFind->second->clear(false);
 468                 m_aPools.erase(aFind);
 469             }
 470         }
 471     }
 472 }
 473
 474 void OPoolCollection::clearDesktop()
 475 {
 476     clearConnectionPools(true);
 477     if ( m_xDesktop.is() )
 478         m_xDesktop->removeTerminateListener(this);
 479     m_xDesktop.clear();
 480 }
 481
 482
 483 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */