odbcappender.cpp

log4cxx 0.10 unix下编译包

/*
 * 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.
 */
#include <log4cxx/db/odbcappender.h>
#include <log4cxx/helpers/loglog.h>
#include <log4cxx/helpers/optionconverter.h>
#include <log4cxx/helpers/stringhelper.h>
#include <log4cxx/helpers/transcoder.h>
#include <log4cxx/patternlayout.h>
#include <apr_strings.h>

#if !defined(LOG4CXX)
#define LOG4CXX 1
#endif
#include <log4cxx/private/log4cxx_private.h>
#if LOG4CXX_HAVE_ODBC
#if defined(WIN32) || defined(_WIN32)
#include <windows.h>
#endif
#include <sqlext.h>
#endif


using namespace log4cxx;
using namespace log4cxx::helpers;
using namespace log4cxx::db;
using namespace log4cxx::spi;

SQLException::SQLException(short fHandleType, 
                           void* hInput, const char* prolog,
                           log4cxx::helpers::Pool& p) 
                           : Exception(formatMessage(fHandleType, hInput, prolog, p)) {
}


SQLException::SQLException(const char* msg) 
   : Exception(msg) {
}

SQLException::SQLException(const SQLException& src) 
   : Exception(src) {
}

const char* SQLException::formatMessage(short fHandleType,
                          void* hInput, const char* prolog, log4cxx::helpers::Pool& p) {
   std::string strReturn(prolog);
   strReturn.append(" - ");
#if LOG4CXX_HAVE_ODBC
   SQLCHAR       SqlState[6];
   SQLCHAR       Msg[SQL_MAX_MESSAGE_LENGTH];
   SQLINTEGER    NativeError;
   SQLSMALLINT   i;
   SQLSMALLINT   MsgLen;
   SQLRETURN     rc2;

   // Get the status records.
   i = 1;
   while ((rc2 = SQLGetDiagRecA(fHandleType, hInput, i, SqlState, &NativeError,
                        Msg, sizeof(Msg), &MsgLen)) != SQL_NO_DATA) 
   {
      strReturn.append((char*) Msg);
      i++;
   }
#else
   strReturn.append("log4cxx built without ODBC support");
#endif

   return apr_pstrdup((apr_pool_t*) p.getAPRPool(), strReturn.c_str());
}


IMPLEMENT_LOG4CXX_OBJECT(ODBCAppender)



ODBCAppender::ODBCAppender()
: connection(0), env(0), bufferSize(1)
{
}

ODBCAppender::~ODBCAppender()
{
   finalize();
}

void ODBCAppender::setOption(const LogString& option, const LogString& value)
{
   if (StringHelper::equalsIgnoreCase(option, LOG4CXX_STR("BUFFERSIZE"), LOG4CXX_STR("buffersize")))
   {
      setBufferSize((size_t)OptionConverter::toInt(value, 1));
   }
   else if (StringHelper::equalsIgnoreCase(option, LOG4CXX_STR("PASSWORD"), LOG4CXX_STR("password")))
   {
      setPassword(value);
   }
   else if (StringHelper::equalsIgnoreCase(option, LOG4CXX_STR("SQL"), LOG4CXX_STR("sql")))
   {
      setSql(value);
   }
   else if (StringHelper::equalsIgnoreCase(option, LOG4CXX_STR("URL"), LOG4CXX_STR("url"))
      || StringHelper::equalsIgnoreCase(option, LOG4CXX_STR("DSN"), LOG4CXX_STR("dsn"))
      || StringHelper::equalsIgnoreCase(option, LOG4CXX_STR("CONNECTIONSTRING"), LOG4CXX_STR("connectionstring"))  )
   {
      setURL(value);
   }
   else if (StringHelper::equalsIgnoreCase(option, LOG4CXX_STR("USER"), LOG4CXX_STR("user")))
   {
      setUser(value);
   }
   else
   {
      AppenderSkeleton::setOption(option, value);
   }
}

void ODBCAppender::activateOptions(log4cxx::helpers::Pool&) {
#if !LOG4CXX_HAVE_ODBC
    LogLog::error(LOG4CXX_STR("Can not activate ODBCAppender unless compiled with ODBC support."));
#endif
}


void ODBCAppender::append(const spi::LoggingEventPtr& event, log4cxx::helpers::Pool& p)
{
#if LOG4CXX_HAVE_ODBC
   buffer.push_back(event);

   if (buffer.size() >= bufferSize)
      flushBuffer(p);
#endif      
}

LogString ODBCAppender::getLogStatement(const spi::LoggingEventPtr& event, log4cxx::helpers::Pool& p) const
{
   LogString sbuf;
   getLayout()->format(sbuf, event, p);
   return sbuf;
}

void ODBCAppender::execute(const LogString& sql, log4cxx::helpers::Pool& p)
{
#if LOG4CXX_HAVE_ODBC
   SQLRETURN ret;
   SQLHDBC con = SQL_NULL_HDBC;
   SQLHSTMT stmt = SQL_NULL_HSTMT;

   try
   {
      con = getConnection(p);

      ret = SQLAllocHandle( SQL_HANDLE_STMT, con, &stmt);
      if (ret < 0)
      {
         throw SQLException( SQL_HANDLE_DBC, con, "Failed to allocate sql handle.", p);
      }

      SQLWCHAR* wsql;
      encode(&wsql, sql, p); 
      ret = SQLExecDirectW(stmt, wsql, SQL_NTS);

     if (ret < 0)
      {
         throw SQLException(SQL_HANDLE_STMT, stmt, "Failed to execute sql statement.", p);
      }
   }
   catch (SQLException& e)
   {
      if (stmt != SQL_NULL_HSTMT)
      {
         SQLFreeHandle(SQL_HANDLE_STMT, stmt);
      }
   
      throw e;
   }
   SQLFreeHandle(SQL_HANDLE_STMT, stmt);
   closeConnection(con);
#else
    throw SQLException("log4cxx build without ODBC support");
#endif
}

/* The default behavior holds a single connection open until the appender
is closed (typically when garbage collected).*/
void ODBCAppender::closeConnection(ODBCAppender::SQLHDBC /* con */)
{
}





ODBCAppender::SQLHDBC ODBCAppender::getConnection(log4cxx::helpers::Pool& p)
{
#if LOG4CXX_HAVE_ODBC
   SQLRETURN ret;

   if (env == SQL_NULL_HENV)
   {
      ret = SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &env);
      if (ret < 0)
      {
         SQLException ex(SQL_HANDLE_ENV, env, "Failed to allocate SQL handle.", p);
         env = SQL_NULL_HENV;
         throw ex;
      }

      ret = SQLSetEnvAttr(env, SQL_ATTR_ODBC_VERSION, (SQLPOINTER) SQL_OV_ODBC3, SQL_IS_INTEGER);
      if (ret < 0)
      {
         SQLException ex(SQL_HANDLE_ENV, env, "Failed to set odbc version.", p);
         SQLFreeHandle(SQL_HANDLE_ENV, env);
         env = SQL_NULL_HENV;
         throw ex;
      }
   }

   if (connection == SQL_NULL_HDBC)
   {
      ret = SQLAllocHandle(SQL_HANDLE_DBC, env, &connection);
      if (ret < 0)
      {
         SQLException ex(SQL_HANDLE_DBC, connection, "Failed to allocate sql handle.", p);
         connection = SQL_NULL_HDBC;
         throw ex;
      }


     SQLWCHAR *wURL, *wUser, *wPwd;
     encode(&wURL, databaseURL, p);
     encode(&wUser, databaseUser, p);
     encode(&wPwd, databasePassword, p);

     ret = SQLConnectW( connection, 
            wURL, SQL_NTS, 
            wUser, SQL_NTS,
            wPwd, SQL_NTS);


     if (ret < 0)
      {
         SQLException ex(SQL_HANDLE_DBC, connection, "Failed to connect to database.", p);
         SQLFreeHandle(SQL_HANDLE_DBC, connection);
         connection = SQL_NULL_HDBC;
         throw ex;
      }
   }

   return connection;
#else
   return 0;
#endif   
}

void ODBCAppender::close()
{
   if (closed) {
       return;
   }
   Pool p;
   try
   {
      flushBuffer(p);
   }
   catch (SQLException& e)
   {
      errorHandler->error(LOG4CXX_STR("Error closing connection"),
         e, ErrorCode::GENERIC_FAILURE);
   }
#if LOG4CXX_HAVE_ODBC
   if (connection != SQL_NULL_HDBC)
   {
      SQLDisconnect(connection);
      SQLFreeHandle(SQL_HANDLE_DBC, connection);
   }

   if (env != SQL_NULL_HENV)
   {
      SQLFreeHandle(SQL_HANDLE_ENV, env);
   }
#endif
   this->closed = true;
}

void ODBCAppender::flushBuffer(Pool& p)
{
   std::list<spi::LoggingEventPtr>::iterator i;
   for (i = buffer.begin(); i != buffer.end(); i++)
   {
      try
      {
         const LoggingEventPtr& logEvent = *i;
         LogString sql = getLogStatement(logEvent, p);
         execute(sql, p);
      }
      catch (SQLException& e)
      {
         errorHandler->error(LOG4CXX_STR("Failed to excute sql"), e,
            ErrorCode::FLUSH_FAILURE);
      }
   }

   // clear the buffer of reported events
   buffer.clear();
}

void ODBCAppender::setSql(const LogString& s)
{
   sqlStatement = s;
   if (getLayout() == 0)
   {
      this->setLayout(new PatternLayout(s));
   }
   else
   {
      PatternLayoutPtr patternLayout = this->getLayout();
      if (patternLayout != 0)
      {
         patternLayout->setConversionPattern(s);
      }
   }
}

void ODBCAppender::encode(wchar_t** dest, const LogString& src, Pool& p) {
   *dest = Transcoder::wencode(src, p);
}
#ifndef WIN32
void ODBCAppender::encode( unsigned short** dest, 
    const LogString& src, Pool& p) {
   //  worst case double number of characters from UTF-8 or wchar_t
   *dest = (unsigned short*) 
        p.palloc((src.size() + 1) * 2 * sizeof(unsigned short));
     unsigned short* current = *dest;
   for(LogString::const_iterator i = src.begin();
      i != src.end();) {
      unsigned int sv = Transcoder::decode(src, i);
      if (sv < 0x10000) {
	 *current++ = (unsigned short) sv;
      } else {
        unsigned char u = (unsigned char) (sv >> 16);
        unsigned char w = (unsigned char) (u - 1);
        unsigned short hs = (0xD800 + ((w & 0xF) << 6) + ((sv & 0xFFFF) >> 10));
        unsigned short ls = (0xDC00 + (sv && 0x3FF));
	*current++ = (unsigned short) hs;
	*current++ = (unsigned short) ls;
      }
  }
  *current = 0;
}
#endif