ucb/source/ucp/webdav/SerfLockStore.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 <rtl/ustring.hxx>
  21 #include <osl/time.h>
  22 #include <osl/thread.hxx>
  23 #include "SerfSession.hxx"
  24 #include "SerfLockStore.hxx"
  25
  26 using namespace http_dav_ucp;
  27
  28 namespace http_dav_ucp {
  29
  30 class TickerThread : public osl::Thread
  31 {
  32     bool m_bFinish;
  33     SerfLockStore & m_rLockStore;
  34
  35 public:
  36
  37     TickerThread( SerfLockStore & rLockStore )
  38     : osl::Thread(), m_bFinish( false ), m_rLockStore( rLockStore ) {}
  39
  40     void finish() { m_bFinish = true; }
  41
  42 protected:
  43
  44     virtual void SAL_CALL run() SAL_OVERRIDE;
  45 };
  46
  47 } // namespace http_dav_ucp
  48
  49
  50 void TickerThread::run()
  51 {
  52     osl_setThreadName("http_dav_ucp::TickerThread");
  53
  54     SAL_INFO("ucb.ucp.webdav",  "TickerThread: start." );
  55
  56     // we have to go through the loop more often to be able to finish ~quickly
  57     const int nNth = 25;
  58
  59     int nCount = nNth;
  60     while ( !m_bFinish )
  61     {
  62         if ( nCount-- <= 0 )
  63         {
  64             m_rLockStore.refreshLocks();
  65             nCount = nNth;
  66         }
  67
  68         TimeValue aTV;
  69         aTV.Seconds = 0;
  70         aTV.Nanosec = 1000000000 / nNth;
  71         wait( aTV );
  72     }
  73
  74     SAL_INFO("ucb.ucp.webdav",  "TickerThread: stop." );
  75 }
  76
  77
  78 SerfLockStore::SerfLockStore()
  79     : m_pTickerThread( 0 )
  80     , m_bFinishing( false )
  81 {
  82 }
  83
  84
  85 SerfLockStore::~SerfLockStore()
  86 {
  87     stopTicker();
  88     m_bFinishing = true;
  89
  90     // release active locks, if any.
  91     SAL_WARN_IF( !m_aLockInfoMap.empty(), "ucb.ucp.webdav",
  92                 "SerfLockStore::~SerfLockStore - Releasing active locks!" );
  93
  94     LockInfoMap::const_iterator it( m_aLockInfoMap.begin() );
  95     const LockInfoMap::const_iterator end( m_aLockInfoMap.end() );
  96     while ( it != end )
  97     {
  98         (*it).second.m_xSession->UNLOCK( (*it).first );
  99         ++it;
 100     }
 101 }
 102
 103 bool SerfLockStore::finishing() const
 104 {
 105     return m_bFinishing;
 106 }
 107
 108 void SerfLockStore::startTicker()
 109 {
 110     osl::MutexGuard aGuard( m_aMutex );
 111
 112     if ( !m_pTickerThread )
 113     {
 114         m_pTickerThread = new TickerThread( *this );
 115         m_pTickerThread->create();
 116     }
 117 }
 118
 119
 120 void SerfLockStore::stopTicker()
 121 {
 122     osl::MutexGuard aGuard( m_aMutex );
 123
 124     if ( m_pTickerThread )
 125     {
 126         m_pTickerThread->finish();
 127         m_pTickerThread->join();
 128         delete m_pTickerThread;
 129         m_pTickerThread = 0;
 130     }
 131 }
 132
 133 OUString SerfLockStore::getLockToken( const OUString& rLock )
 134 {
 135     osl::MutexGuard aGuard( m_aMutex );
 136
 137     LockInfoMap::const_iterator it( m_aLockInfoMap.find( rLock ) );
 138     if ( it != m_aLockInfoMap.end() )
 139         return (*it).second.m_sToken;
 140
 141     SAL_WARN("ucb.ucp.webdav", "SerfLockStore::getLockToken: lock not found!" );
 142     return OUString();
 143 }
 144
 145 void SerfLockStore::addLock( const OUString& rLock,
 146                              const OUString& sToken,
 147                              rtl::Reference< SerfSession > const & xSession,
 148                              sal_Int32 nLastChanceToSendRefreshRequest )
 149 {
 150     osl::MutexGuard aGuard( m_aMutex );
 151
 152     m_aLockInfoMap[ rLock ]
 153         = LockInfo( sToken, xSession, nLastChanceToSendRefreshRequest );
 154
 155     startTicker();
 156 }
 157
 158
 159 void SerfLockStore::updateLock( const OUString& rLock,
 160                                 sal_Int32 nLastChanceToSendRefreshRequest )
 161 {
 162     osl::MutexGuard aGuard( m_aMutex );
 163
 164     LockInfoMap::iterator it( m_aLockInfoMap.find( rLock ) );
 165     SAL_WARN_IF( it == m_aLockInfoMap.end(), "ucb.ucp.webdav",
 166                 "SerfLockStore::updateLock: lock not found!" );
 167
 168     if ( it != m_aLockInfoMap.end() )
 169     {
 170         (*it).second.m_nLastChanceToSendRefreshRequest
 171             = nLastChanceToSendRefreshRequest;
 172     }
 173 }
 174
 175
 176 void SerfLockStore::removeLock( const OUString& rLock )
 177 {
 178     osl::MutexGuard aGuard( m_aMutex );
 179
 180     m_aLockInfoMap.erase( rLock );
 181
 182     if ( m_aLockInfoMap.empty() )
 183         stopTicker();
 184 }
 185
 186
 187 void SerfLockStore::refreshLocks()
 188 {
 189     osl::MutexGuard aGuard( m_aMutex );
 190
 191     LockInfoMap::iterator it( m_aLockInfoMap.begin() );
 192     const LockInfoMap::const_iterator end( m_aLockInfoMap.end() );
 193     while ( it != end )
 194     {
 195         LockInfo & rInfo = (*it).second;
 196         if ( rInfo.m_nLastChanceToSendRefreshRequest != -1 )
 197         {
 198             // 30 seconds or less remaining until lock expires?
 199             TimeValue t1;
 200             osl_getSystemTime( &t1 );
 201             if ( rInfo.m_nLastChanceToSendRefreshRequest - 30
 202                      <= sal_Int32( t1.Seconds ) )
 203             {
 204                 // refresh the lock.
 205                 sal_Int32 nlastChanceToSendRefreshRequest = -1;
 206                 if ( rInfo.m_xSession->LOCK(
 207                          (*it).first, &nlastChanceToSendRefreshRequest ) )
 208                 {
 209                     rInfo.m_nLastChanceToSendRefreshRequest
 210                         = nlastChanceToSendRefreshRequest;
 211                 }
 212                 else
 213                 {
 214                     // refresh failed. stop auto-refresh.
 215                     rInfo.m_nLastChanceToSendRefreshRequest = -1;
 216                 }
 217             }
 218         }
 219         ++it;
 220     }
 221 }
 222
 223 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */