/**************************************************************
*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*
*************************************************************/
// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_extensions.hxx"
#include "loggerconfig.hxx"
#include <stdio.h>
/** === begin UNO includes === **/
#include <com/sun/star/lang/XMultiServiceFactory.hpp>
#include <com/sun/star/container/XNameContainer.hpp>
#include <com/sun/star/lang/XSingleServiceFactory.hpp>
#include <com/sun/star/util/XChangesBatch.hpp>
#include <com/sun/star/logging/LogLevel.hpp>
#include <com/sun/star/lang/NullPointerException.hpp>
#include <com/sun/star/lang/ServiceNotRegisteredException.hpp>
#include <com/sun/star/beans/NamedValue.hpp>
#include <com/sun/star/logging/XLogHandler.hpp>
#include <com/sun/star/logging/XLogFormatter.hpp>
/** === end UNO includes === **/
#include <tools/diagnose_ex.h>
#include <osl/process.h>
#include <rtl/ustrbuf.hxx>
#include <comphelper/componentcontext.hxx>
#include <cppuhelper/component_context.hxx>
#include <vector>
//........................................................................
namespace logging
{
//........................................................................
/** === begin UNO using === **/
using ::com::sun::star::uno::Reference;
using ::com::sun::star::logging::XLogger;
using ::com::sun::star::lang::XMultiServiceFactory;
using ::com::sun::star::uno::Sequence;
using ::com::sun::star::uno::Any;
using ::com::sun::star::container::XNameContainer;
using ::com::sun::star::uno::UNO_QUERY_THROW;
using ::com::sun::star::lang::XSingleServiceFactory;
using ::com::sun::star::uno::XInterface;
using ::com::sun::star::util::XChangesBatch;
using ::com::sun::star::uno::makeAny;
using ::com::sun::star::lang::NullPointerException;
using ::com::sun::star::uno::Exception;
using ::com::sun::star::lang::ServiceNotRegisteredException;
using ::com::sun::star::beans::NamedValue;
using ::com::sun::star::logging::XLogHandler;
using ::com::sun::star::logging::XLogFormatter;
using ::com::sun::star::container::XNameAccess;
using ::com::sun::star::uno::XComponentContext;
/** === end UNO using === **/
namespace LogLevel = ::com::sun::star::logging::LogLevel;
namespace
{
//----------------------------------------------------------------
typedef void (*SettingTranslation)( const Reference< XLogger >&, const ::rtl::OUString&, Any& );
//----------------------------------------------------------------
void lcl_substituteFileHandlerURLVariables_nothrow( const Reference< XLogger >& _rxLogger, ::rtl::OUString& _inout_rFileURL )
{
struct Variable
{
const sal_Char* pVariablePattern;
const sal_Int32 nPatternLength;
rtl_TextEncoding eEncoding;
const ::rtl::OUString sVariableValue;
Variable( const sal_Char* _pVariablePattern, const sal_Int32 _nPatternLength, rtl_TextEncoding _eEncoding,
const ::rtl::OUString& _rVariableValue )
:pVariablePattern( _pVariablePattern )
,nPatternLength( _nPatternLength )
,eEncoding( _eEncoding )
,sVariableValue( _rVariableValue )
{
}
};
::rtl::OUString sLoggerName;
try { sLoggerName = _rxLogger->getName(); }
catch( const Exception& ) { DBG_UNHANDLED_EXCEPTION(); }
TimeValue aTimeValue;
oslDateTime aDateTime;
OSL_VERIFY( osl_getSystemTime( &aTimeValue ) );
OSL_VERIFY( osl_getDateTimeFromTimeValue( &aTimeValue, &aDateTime ) );
char buffer[ 30 ];
const size_t buffer_size = sizeof( buffer );
snprintf( buffer, buffer_size, "%04i-%02i-%02i",
(int)aDateTime.Year,
(int)aDateTime.Month,
(int)aDateTime.Day );
rtl::OUString sDate = rtl::OUString::createFromAscii( buffer );
snprintf( buffer, buffer_size, "%02i-%02i-%02i.%03i",
(int)aDateTime.Hours,
(int)aDateTime.Minutes,
(int)aDateTime.Seconds,
::sal::static_int_cast< sal_Int16 >( aDateTime.NanoSeconds / 10000000 ) );
rtl::OUString sTime = rtl::OUString::createFromAscii( buffer );
rtl::OUStringBuffer aBuff;
aBuff.append( sDate );
aBuff.append( sal_Unicode( '.' ) );
aBuff.append( sTime );
rtl::OUString sDateTime = aBuff.makeStringAndClear();
oslProcessIdentifier aProcessId = 0;
oslProcessInfo info;
info.Size = sizeof (oslProcessInfo);
if ( osl_getProcessInfo ( 0, osl_Process_IDENTIFIER, &info ) == osl_Process_E_None)
aProcessId = info.Ident;
rtl::OUString aPID = rtl::OUString::valueOf( sal_Int64( aProcessId ) );
Variable aVariables[] =
{
Variable( RTL_CONSTASCII_USTRINGPARAM( "$(loggername)" ), sLoggerName ),
Variable( RTL_CONSTASCII_USTRINGPARAM( "$(date)" ), sDate ),
Variable( RTL_CONSTASCII_USTRINGPARAM( "$(time)" ), sTime ),
Variable( RTL_CONSTASCII_USTRINGPARAM( "$(datetime)" ), sDateTime ),
Variable( RTL_CONSTASCII_USTRINGPARAM( "$(pid)" ), aPID )
};
for ( size_t i = 0; i < sizeof( aVariables ) / sizeof( aVariables[0] ); ++i )
{
::rtl::OUString sPattern( aVariables[i].pVariablePattern, aVariables[i].nPatternLength, aVariables[i].eEncoding );
sal_Int32 nVariableIndex = _inout_rFileURL.indexOf( sPattern );
if ( ( nVariableIndex == 0 )
|| ( ( nVariableIndex > 0 )
&& ( sPattern[ nVariableIndex - 1 ] != '$' )
)
)
{
// found an (unescaped) variable
_inout_rFileURL = _inout_rFileURL.replaceAt( nVariableIndex, sPattern.getLength(), aVariables[i].sVariableValue );
}
}
}
//----------------------------------------------------------------
void lcl_transformFileHandlerSettings_nothrow( const Reference< XLogger >& _rxLogger, const ::rtl::OUString& _rSettingName, Any& _inout_rSettingValue )
{
if ( !_rSettingName.equalsAscii( "FileURL" ) )
// not interested in this setting
return;
::rtl::OUString sURL;
OSL_VERIFY( _inout_rSettingValue >>= sURL );
lcl_substituteFileHandlerURLVariables_nothrow( _rxLogger, sURL );
_inout_rSettingValue <<= sURL;
}
//----------------------------------------------------------------
Reference< XInterface > lcl_createInstanceFromSetting_throw(
const ::comphelper::ComponentContext& _rContext,
const Reference< XLogger >& _rxLogger,
const Reference< XNameAccess >& _rxLoggerSettings,
const sal_Char* _pServiceNameAsciiNodeName,
const sal_Char* _pServiceSettingsAsciiNodeName,
SettingTranslation _pSettingTranslation = NULL
)
{
Reference< XInterface > xInstance;
// read the settings for the to-be-created service
Reference< XNameAccess > xServiceSettingsNode( _rxLoggerSettings->getByName(
::rtl::OUString::createFromAscii( _pServiceSettingsAsciiNodeName ) ), UNO_QUERY_THROW );
Sequence< ::rtl::OUString > aSettingNames( xServiceSettingsNode->getElementNames() );
size_t nServiceSettingCount( aSettingNames.getLength() );
Sequence< NamedValue > aSettings( nServiceSettingCount );
if ( nServiceSettingCount )
{
const ::rtl::OUString* pSettingNames = aSettingNames.getConstArray();
const ::rtl::OUString* pSettingNamesEnd = aSettingNames.getConstArray() + aSettingNames.getLength();
NamedValue* pSetting = aSettings.getArray();
for ( ;
pSettingNames != pSettingNamesEnd;
++pSettingNames, ++pSetting
)
{
pSetting->Name = *pSettingNames;
pSetting->Value = xServiceSettingsNode->getByName( *pSettingNames );
if ( _pSettingTranslation )
(_pSettingTranslation)( _rxLogger, pSetting->Name, pSetting->Value );
}
}
::rtl::OUString sServiceName;
_rxLoggerSettings->getByName( ::rtl::OUString::createFromAscii( _pServiceNameAsciiNodeName ) ) >>= sServiceName;
if ( sServiceName.getLength() )
{
bool bSuccess = false;
if ( aSettings.getLength() )
{
Sequence< Any > aConstructionArgs(1);
aConstructionArgs[0] <<= aSettings;
bSuccess = _rContext.createComponentWithArguments( sServiceName, aConstructionArgs, xInstance );
}
else
{
bSuccess = _rContext.createComponent( sServiceName, xInstance );
}
if ( !bSuccess )
throw ServiceNotRegisteredException( sServiceName, NULL );
}
return xInstance;
}
}
//--------------------------------------------------------------------
void initializeLoggerFromConfiguration( const ::comphelper::ComponentContext& _rContext, const Reference< XLogger >& _rxLogger )
{
try
{
if ( !_rxLogger.is() )
throw NullPointerException();
// the configuration provider
Reference< XMultiServiceFactory > xConfigProvider;
::rtl::OUString sConfigProvServiceName( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.configuration.ConfigurationProvider" ) );
if ( !_rContext.createComponent( sConfigProvServiceName, xConfigProvider ) )
throw ServiceNotRegisteredException( sConfigProvServiceName, _rxLogger );
// write access to the "Settings" node (which includes settings for all loggers)
Sequence< Any > aArguments(1);
aArguments[0] <<= NamedValue(
::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "nodepath" ) ),
makeAny( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "/org.openoffice.Office.Logging/Settings" ) ) )
);
Reference< XNameContainer > xAllSettings( xConfigProvider->createInstanceWithArguments(
::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.configuration.ConfigurationUpdateAccess" ) ),
aArguments
), UNO_QUERY_THROW );
::rtl::OUString sLoggerName( _rxLogger->getName() );
if ( !xAllSettings->hasByName( sLoggerName ) )
{
// no node yet for this logger. Create default settings.
Reference< XSingleServiceFactory > xNodeFactory( xAllSettings, UNO_QUERY_THROW );
Reference< XInterface > xLoggerSettings( xNodeFactory->createInstance(), UNO_QUERY_THROW );
xAllSettings->insertByName( sLoggerName, makeAny( xLoggerSettings ) );
Reference< XChangesBatch > xChanges( xAllSettings, UNO_QUERY_THROW );
xChanges->commitChanges();
}
// actually read and forward the settings
Reference< XNameAccess > xLoggerSettings( xAllSettings->getByName( sLoggerName ), UNO_QUERY_THROW );
// the log level
sal_Int32 nLogLevel( LogLevel::OFF );
OSL_VERIFY( xLoggerSettings->getByName( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "LogLevel" ) ) ) >>= nLogLevel );
_rxLogger->setLevel( nLogLevel );
// the default handler, if any
Reference< XInterface > xUntyped( lcl_createInstanceFromSetting_throw( _rContext, _rxLogger, xLoggerSettings, "DefaultHandler", "HandlerSettings", &lcl_transformFileHandlerSettings_nothrow ) );
if ( !xUntyped.is() )
// no handler -> we're done
return;
Reference< XLogHandler > xHandler( xUntyped, UNO_QUERY_THROW );
_rxLogger->addLogHandler( xHandler );
// The newly created handler might have an own (default) level. Ensure that it uses
// the same level as the logger.
xHandler->setLevel( nLogLevel );
// the default formatter for the handler
xUntyped = lcl_createInstanceFromSetting_throw( _rContext, _rxLogger, xLoggerSettings, "DefaultFormatter", "FormatterSettings" );
if ( !xUntyped.is() )
// no formatter -> we're done
return;
Reference< XLogFormatter > xFormatter( xUntyped, UNO_QUERY_THROW );
xHandler->setFormatter( xFormatter );
// TODO: we could first create the formatter, then the handler. This would allow
// passing the formatter as value in the component context, so the handler would
// not create an own default formatter
}
catch( const Exception& )
{
DBG_UNHANDLED_EXCEPTION();
}
}
//........................................................................
} // namespace logging
//........................................................................