extensions/source/logging/filehandler.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
  21 #include "log_module.hxx"
  22 #include "methodguard.hxx"
  23 #include "loghandler.hxx"
  24
  25 #include <com/sun/star/logging/XLogHandler.hpp>
  26 #include <com/sun/star/lang/XServiceInfo.hpp>
  27 #include <com/sun/star/ucb/AlreadyInitializedException.hpp>
  28 #include <com/sun/star/lang/XInitialization.hpp>
  29 #include <com/sun/star/lang/IllegalArgumentException.hpp>
  30 #include <com/sun/star/util/PathSubstitution.hpp>
  31 #include <com/sun/star/util/XStringSubstitution.hpp>
  32
  33 #include <tools/diagnose_ex.h>
  34
  35 #include <comphelper/componentcontext.hxx>
  36
  37 #include <cppuhelper/compbase3.hxx>
  38 #include <cppuhelper/basemutex.hxx>
  39
  40 #include <osl/thread.h>
  41 #include <osl/file.hxx>
  42
  43 #include <rtl/strbuf.hxx>
  44
  45 #include <memory>
  46
  47 //........................................................................
  48 namespace logging
  49 {
  50 //........................................................................
  51
  52     using ::com::sun::star::uno::Reference;
  53     using ::com::sun::star::logging::LogRecord;
  54     using ::com::sun::star::uno::RuntimeException;
  55     using ::com::sun::star::logging::XLogFormatter;
  56     using ::com::sun::star::uno::Sequence;
  57     using ::com::sun::star::uno::XInterface;
  58     using ::com::sun::star::uno::XComponentContext;
  59     using ::com::sun::star::logging::XLogHandler;
  60     using ::com::sun::star::lang::XServiceInfo;
  61     using ::com::sun::star::ucb::AlreadyInitializedException;
  62     using ::com::sun::star::lang::XInitialization;
  63     using ::com::sun::star::uno::Any;
  64     using ::com::sun::star::uno::Exception;
  65     using ::com::sun::star::lang::IllegalArgumentException;
  66     using ::com::sun::star::uno::UNO_QUERY_THROW;
  67     using ::com::sun::star::util::PathSubstitution;
  68     using ::com::sun::star::util::XStringSubstitution;
  69     using ::com::sun::star::beans::NamedValue;
  70
  71     //====================================================================
  72     //= FileHandler - declaration
  73     //====================================================================
  74     typedef ::cppu::WeakComponentImplHelper3    <   XLogHandler
  75                                                 ,   XServiceInfo
  76                                                 ,   XInitialization
  77                                                 >   FileHandler_Base;
  78     class FileHandler   :public ::cppu::BaseMutex
  79                         ,public FileHandler_Base
  80     {
  81     private:
  82         enum FileValidity
  83         {
  84             /// never attempted to open the file
  85             eUnknown,
  86             /// file is valid
  87             eValid,
  88             /// file is invalid
  89             eInvalid
  90         };
  91
  92     private:
  93         ::comphelper::ComponentContext  m_aContext;
  94         LogHandlerHelper                m_aHandlerHelper;
  95         OUString                 m_sFileURL;
  96         ::std::auto_ptr< ::osl::File >  m_pFile;
  97         FileValidity                    m_eFileValidity;
  98
  99     protected:
 100         FileHandler( const Reference< XComponentContext >& _rxContext );
 101         virtual ~FileHandler();
 102
 103         // XLogHandler
 104         virtual OUString SAL_CALL getEncoding() throw (RuntimeException);
 105         virtual void SAL_CALL setEncoding( const OUString& _encoding ) throw (RuntimeException);
 106         virtual Reference< XLogFormatter > SAL_CALL getFormatter() throw (RuntimeException);
 107         virtual void SAL_CALL setFormatter( const Reference< XLogFormatter >& _formatter ) throw (RuntimeException);
 108         virtual ::sal_Int32 SAL_CALL getLevel() throw (RuntimeException);
 109         virtual void SAL_CALL setLevel( ::sal_Int32 _level ) throw (RuntimeException);
 110         virtual void SAL_CALL flush(  ) throw (RuntimeException);
 111         virtual ::sal_Bool SAL_CALL publish( const LogRecord& Record ) throw (RuntimeException);
 112
 113         // XInitialization
 114         virtual void SAL_CALL initialize( const ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Any >& aArguments ) throw (::com::sun::star::uno::Exception, ::com::sun::star::uno::RuntimeException);
 115
 116         // XServiceInfo
 117         virtual OUString SAL_CALL getImplementationName() throw(RuntimeException);
 118         virtual ::sal_Bool SAL_CALL supportsService( const OUString& _rServiceName ) throw(RuntimeException);
 119         virtual Sequence< OUString > SAL_CALL getSupportedServiceNames() throw(RuntimeException);
 120
 121         // OComponentHelper
 122         virtual void SAL_CALL disposing();
 123
 124     public:
 125         // XServiceInfo - static version
 126         static OUString SAL_CALL getImplementationName_static();
 127         static Sequence< OUString > SAL_CALL getSupportedServiceNames_static();
 128         static Reference< XInterface > Create( const Reference< XComponentContext >& _rxContext );
 129
 130     public:
 131         typedef ComponentMethodGuard< FileHandler > MethodGuard;
 132         void    enterMethod( MethodGuard::Access );
 133         void    leaveMethod( MethodGuard::Access );
 134
 135     private:
 136         /** prepares our output file for writing
 137         */
 138         bool    impl_prepareFile_nothrow();
 139
 140         /// writes the given string to our file
 141         void    impl_writeString_nothrow( const OString& _rEntry );
 142
 143         /** does string substitution on a (usually externally provided) file url
 144         */
 145         void    impl_doStringsubstitution_nothrow( OUString& _inout_rURL );
 146     };
 147
 148     //====================================================================
 149     //= FileHandler - implementation
 150     //====================================================================
 151     //--------------------------------------------------------------------
 152     FileHandler::FileHandler( const Reference< XComponentContext >& _rxContext )
 153         :FileHandler_Base( m_aMutex )
 154         ,m_aContext( _rxContext )
 155         ,m_aHandlerHelper( _rxContext, m_aMutex, rBHelper )
 156         ,m_sFileURL( )
 157         ,m_pFile( )
 158         ,m_eFileValidity( eUnknown )
 159     {
 160     }
 161
 162     //--------------------------------------------------------------------
 163     FileHandler::~FileHandler()
 164     {
 165         if ( !rBHelper.bDisposed )
 166         {
 167             acquire();
 168             dispose();
 169         }
 170     }
 171
 172     //--------------------------------------------------------------------
 173     bool FileHandler::impl_prepareFile_nothrow()
 174     {
 175         if ( m_eFileValidity == eUnknown )
 176         {
 177             m_pFile.reset( new ::osl::File( m_sFileURL ) );
 178             // check whether the log file already exists
 179             ::osl::DirectoryItem aFileItem;
 180             ::osl::DirectoryItem::get( m_sFileURL, aFileItem );
 181             ::osl::FileStatus aStatus( osl_FileStatus_Mask_Validate );
 182             if ( ::osl::FileBase::E_None == aFileItem.getFileStatus( aStatus ) )
 183                 ::osl::File::remove( m_sFileURL );
 184
 185             ::osl::FileBase::RC res = m_pFile->open( osl_File_OpenFlag_Write | osl_File_OpenFlag_Create );
 186             m_eFileValidity =   res == ::osl::FileBase::E_None
 187                             ?   eValid
 188                             :   eInvalid;
 189         #if OSL_DEBUG_LEVEL > 0
 190             if ( m_eFileValidity == eInvalid )
 191             {
 192                 OStringBuffer sMessage;
 193                 sMessage.append( "FileHandler::impl_prepareFile_nothrow: could not open the designated log file:" );
 194                 sMessage.append( "\nURL: " );
 195                 sMessage.append( OString( m_sFileURL.getStr(), m_sFileURL.getLength(), osl_getThreadTextEncoding() ) );
 196                 sMessage.append( "\nerror code: " );
 197                 sMessage.append( (sal_Int32)res );
 198                 OSL_FAIL( sMessage.makeStringAndClear().getStr() );
 199             }
 200         #endif
 201             if ( m_eFileValidity == eValid )
 202             {
 203                 OString sHead;
 204                 if ( m_aHandlerHelper.getEncodedHead( sHead ) )
 205                     impl_writeString_nothrow( sHead );
 206             }
 207         }
 208
 209         return m_eFileValidity == eValid;
 210     }
 211
 212     //--------------------------------------------------------------------
 213     void FileHandler::impl_writeString_nothrow( const OString& _rEntry )
 214     {
 215         OSL_PRECOND( m_pFile.get(), "FileHandler::impl_writeString_nothrow: no file!" );
 216
 217         sal_uInt64 nBytesToWrite( _rEntry.getLength() );
 218         sal_uInt64 nBytesWritten( 0 );
 219     #if OSL_DEBUG_LEVEL > 0
 220         ::osl::FileBase::RC res =
 221     #endif
 222         m_pFile->write( _rEntry.getStr(), nBytesToWrite, nBytesWritten );
 223         OSL_ENSURE( ( res == ::osl::FileBase::E_None ) && ( nBytesWritten == nBytesToWrite ),
 224             "FileHandler::impl_writeString_nothrow: could not write the log entry!" );
 225     }
 226
 227     //--------------------------------------------------------------------
 228     void FileHandler::impl_doStringsubstitution_nothrow( OUString& _inout_rURL )
 229     {
 230         try
 231         {
 232             Reference< XStringSubstitution > xStringSubst(PathSubstitution::create(m_aContext.getUNOContext()));
 233             _inout_rURL = xStringSubst->substituteVariables( _inout_rURL, true );
 234         }
 235         catch( const Exception& )
 236         {
 237             DBG_UNHANDLED_EXCEPTION();
 238         }
 239     }
 240
 241     //--------------------------------------------------------------------
 242     void SAL_CALL FileHandler::disposing()
 243     {
 244         if ( m_eFileValidity == eValid )
 245         {
 246             OString sTail;
 247             if ( m_aHandlerHelper.getEncodedTail( sTail ) )
 248                 impl_writeString_nothrow( sTail );
 249         }
 250
 251         m_pFile.reset( NULL );
 252         m_aHandlerHelper.setFormatter( NULL );
 253     }
 254
 255     //--------------------------------------------------------------------
 256     void FileHandler::enterMethod( MethodGuard::Access )
 257     {
 258         m_aHandlerHelper.enterMethod();
 259     }
 260
 261     //--------------------------------------------------------------------
 262     void FileHandler::leaveMethod( MethodGuard::Access )
 263     {
 264         m_aMutex.release();
 265     }
 266
 267     //--------------------------------------------------------------------
 268     OUString SAL_CALL FileHandler::getEncoding() throw (RuntimeException)
 269     {
 270         MethodGuard aGuard( *this );
 271         OUString sEncoding;
 272         OSL_VERIFY( m_aHandlerHelper.getEncoding( sEncoding ) );
 273         return sEncoding;
 274     }
 275
 276     //--------------------------------------------------------------------
 277     void SAL_CALL FileHandler::setEncoding( const OUString& _rEncoding ) throw (RuntimeException)
 278     {
 279         MethodGuard aGuard( *this );
 280         OSL_VERIFY( m_aHandlerHelper.setEncoding( _rEncoding ) );
 281     }
 282
 283     //--------------------------------------------------------------------
 284     Reference< XLogFormatter > SAL_CALL FileHandler::getFormatter() throw (RuntimeException)
 285     {
 286         MethodGuard aGuard( *this );
 287         return m_aHandlerHelper.getFormatter();
 288     }
 289
 290     //--------------------------------------------------------------------
 291     void SAL_CALL FileHandler::setFormatter( const Reference< XLogFormatter >& _rxFormatter ) throw (RuntimeException)
 292     {
 293         MethodGuard aGuard( *this );
 294         m_aHandlerHelper.setFormatter( _rxFormatter );
 295     }
 296
 297     //--------------------------------------------------------------------
 298     ::sal_Int32 SAL_CALL FileHandler::getLevel() throw (RuntimeException)
 299     {
 300         MethodGuard aGuard( *this );
 301         return m_aHandlerHelper.getLevel();
 302     }
 303
 304     //--------------------------------------------------------------------
 305     void SAL_CALL FileHandler::setLevel( ::sal_Int32 _nLevel ) throw (RuntimeException)
 306     {
 307         MethodGuard aGuard( *this );
 308         m_aHandlerHelper.setLevel( _nLevel );
 309     }
 310
 311     //--------------------------------------------------------------------
 312     void SAL_CALL FileHandler::flush(  ) throw (RuntimeException)
 313     {
 314         MethodGuard aGuard( *this );
 315         if(!m_pFile.get())
 316         {
 317             OSL_PRECOND(false, "FileHandler::flush: no file!");
 318             return;
 319         }
 320         #if OSL_DEBUG_LEVEL > 0
 321             ::osl::FileBase::RC res =
 322         #endif
 323                 m_pFile->sync();
 324         OSL_ENSURE(res == ::osl::FileBase::E_None, "FileHandler::flush: Could not sync logfile to filesystem.");
 325     }
 326
 327     //--------------------------------------------------------------------
 328     ::sal_Bool SAL_CALL FileHandler::publish( const LogRecord& _rRecord ) throw (RuntimeException)
 329     {
 330         MethodGuard aGuard( *this );
 331
 332         if ( !impl_prepareFile_nothrow() )
 333             return sal_False;
 334
 335         OString sEntry;
 336         if ( !m_aHandlerHelper.formatForPublishing( _rRecord, sEntry ) )
 337             return sal_False;
 338
 339         impl_writeString_nothrow( sEntry );
 340         return sal_True;
 341     }
 342
 343     //--------------------------------------------------------------------
 344     void SAL_CALL FileHandler::initialize( const Sequence< Any >& _rArguments ) throw (Exception, RuntimeException)
 345     {
 346         ::osl::MutexGuard aGuard( m_aMutex );
 347
 348         if ( m_aHandlerHelper.getIsInitialized() )
 349             throw AlreadyInitializedException();
 350
 351         if ( _rArguments.getLength() != 1 )
 352             throw IllegalArgumentException( OUString(), *this, 1 );
 353
 354         Sequence< NamedValue > aSettings;
 355         if ( _rArguments[0] >>= m_sFileURL )
 356         {
 357             // create( [in] string URL );
 358             impl_doStringsubstitution_nothrow( m_sFileURL );
 359         }
 360         else if ( _rArguments[0] >>= aSettings )
 361         {
 362             // createWithSettings( [in] sequence< ::com::sun::star::beans::NamedValue > Settings )
 363             ::comphelper::NamedValueCollection aTypedSettings( aSettings );
 364             m_aHandlerHelper.initFromSettings( aTypedSettings );
 365
 366             if ( aTypedSettings.get_ensureType( "FileURL", m_sFileURL ) )
 367                 impl_doStringsubstitution_nothrow( m_sFileURL );
 368         }
 369         else
 370             throw IllegalArgumentException( OUString(), *this, 1 );
 371
 372         m_aHandlerHelper.setIsInitialized();
 373     }
 374
 375     //--------------------------------------------------------------------
 376     OUString SAL_CALL FileHandler::getImplementationName() throw(RuntimeException)
 377     {
 378         return getImplementationName_static();
 379     }
 380
 381     //--------------------------------------------------------------------
 382     ::sal_Bool SAL_CALL FileHandler::supportsService( const OUString& _rServiceName ) throw(RuntimeException)
 383     {
 384         const Sequence< OUString > aServiceNames( getSupportedServiceNames() );
 385         for (   const OUString* pServiceNames = aServiceNames.getConstArray();
 386                 pServiceNames != aServiceNames.getConstArray() + aServiceNames.getLength();
 387                 ++pServiceNames
 388             )
 389             if ( _rServiceName == *pServiceNames )
 390                 return sal_True;
 391         return sal_False;
 392     }
 393
 394     //--------------------------------------------------------------------
 395     Sequence< OUString > SAL_CALL FileHandler::getSupportedServiceNames() throw(RuntimeException)
 396     {
 397         return getSupportedServiceNames_static();
 398     }
 399
 400     //--------------------------------------------------------------------
 401     OUString SAL_CALL FileHandler::getImplementationName_static()
 402     {
 403         return OUString( "com.sun.star.comp.extensions.FileHandler" );
 404     }
 405
 406     //--------------------------------------------------------------------
 407     Sequence< OUString > SAL_CALL FileHandler::getSupportedServiceNames_static()
 408     {
 409         Sequence< OUString > aServiceNames(1);
 410         aServiceNames[0] = OUString( "com.sun.star.logging.FileHandler" );
 411         return aServiceNames;
 412     }
 413
 414     //--------------------------------------------------------------------
 415     Reference< XInterface > FileHandler::Create( const Reference< XComponentContext >& _rxContext )
 416     {
 417         return *( new FileHandler( _rxContext ) );
 418     }
 419
 420     //--------------------------------------------------------------------
 421     void createRegistryInfo_FileHandler()
 422     {
 423         static OAutoRegistration< FileHandler > aAutoRegistration;
 424     }
 425
 426 //........................................................................
 427 } // namespace logging
 428 //........................................................................
 429
 430 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */