smtpappender.cpp

log4cxx 0.10 unix下编译包

}


LogString SMTPAppender::getFrom() const {
    return from;
}

void SMTPAppender::setFrom(const LogString& newVal) {
    from = newVal;
}


LogString SMTPAppender::getSubject() const {
    return subject;
}

void SMTPAppender::setSubject(const LogString& newVal) {
    subject = newVal;
}

LogString SMTPAppender::getSMTPHost() const {
    return smtpHost;
}

void SMTPAppender::setSMTPHost(const LogString& newVal) {
    smtpHost = newVal;
}

int SMTPAppender::getSMTPPort() const {
    return smtpPort;
}

void SMTPAppender::setSMTPPort(int newVal) {
    smtpPort = newVal;
}

bool SMTPAppender::getLocationInfo() const {
   return locationInfo;
}

void SMTPAppender::setLocationInfo(bool newVal) { 
    locationInfo = newVal; 
}

LogString SMTPAppender::getSMTPUsername() const {
    return smtpUsername;
}

void SMTPAppender::setSMTPUsername(const LogString& newVal) {
    smtpUsername = newVal;
}

LogString SMTPAppender::getSMTPPassword() const {
    return smtpPassword;
}

void SMTPAppender::setSMTPPassword(const LogString& newVal) {
    smtpPassword = newVal;
}





void SMTPAppender::setOption(const LogString& option,
   const LogString& value)
{
   if (StringHelper::equalsIgnoreCase(option, LOG4CXX_STR("BUFFERSIZE"), LOG4CXX_STR("buffersize")))
   {
      setBufferSize(OptionConverter::toInt(value, 512));
   }
   else if (StringHelper::equalsIgnoreCase(option, LOG4CXX_STR("EVALUATORCLASS"), LOG4CXX_STR("evaluatorclass")))
   {
      setEvaluatorClass(value);
   }
   else if (StringHelper::equalsIgnoreCase(option, LOG4CXX_STR("FROM"), LOG4CXX_STR("from")))
   {
      setFrom(value);
   }
   else if (StringHelper::equalsIgnoreCase(option, LOG4CXX_STR("SMTPHOST"), LOG4CXX_STR("smtphost")))
   {
      setSMTPHost(value);
   }
   else if (StringHelper::equalsIgnoreCase(option, LOG4CXX_STR("SMTPUSERNAME"), LOG4CXX_STR("smtpusername")))
   {
      setSMTPUsername(value);
   }
   else if (StringHelper::equalsIgnoreCase(option, LOG4CXX_STR("SMTPPASSWORD"), LOG4CXX_STR("smtppassword")))
   {
      setSMTPPassword(value);
   }
   else if (StringHelper::equalsIgnoreCase(option, LOG4CXX_STR("SUBJECT"), LOG4CXX_STR("subject")))
   {
      setSubject(value);
   }
   else if (StringHelper::equalsIgnoreCase(option, LOG4CXX_STR("TO"), LOG4CXX_STR("to")))
   {
      setTo(value);
   }
   else if (StringHelper::equalsIgnoreCase(option, LOG4CXX_STR("CC"), LOG4CXX_STR("cc")))
   {
      setCc(value);
   }
   else if (StringHelper::equalsIgnoreCase(option, LOG4CXX_STR("BCC"), LOG4CXX_STR("bcc")))
   {
      setBcc(value);
   }
   else if (StringHelper::equalsIgnoreCase(option, LOG4CXX_STR("SMTPPORT"), LOG4CXX_STR("smtpport")))
   {
      setSMTPPort(OptionConverter::toInt(value, 25));
   }
   else
   {
      AppenderSkeleton::setOption(option, value);
   }
}


bool SMTPAppender::asciiCheck(const LogString& value, const LogString& field) {
     for(LogString::const_iterator iter = value.begin();
         iter != value.end();
         iter++) {
         if (0x7F < (unsigned int) *iter) {
            LogLog::warn(field + LOG4CXX_STR(" contains non-ASCII character"));
            return false;
         } 
     }
     return true;
}

/**
Activate the specified options, such as the smtp host, the
recipient, from, etc. */
void SMTPAppender::activateOptions(Pool& p)
{
   bool activate = true;
   if (layout == 0) {
      errorHandler->error(LOG4CXX_STR("No layout set for appender named [") +name+ LOG4CXX_STR("]."));
      activate = false;
   }
   if(evaluator == 0) {
      errorHandler->error(LOG4CXX_STR("No TriggeringEventEvaluator is set for appender [")+
          name+LOG4CXX_STR("]."));
      activate = false;
   }
   if(smtpHost.empty()) {
      errorHandler->error(LOG4CXX_STR("No smtpHost is set for appender [")+
          name+LOG4CXX_STR("]."));
      activate = false;
   }
   if(to.empty() && cc.empty() && bcc.empty()) {
      errorHandler->error(LOG4CXX_STR("No recipient address is set for appender [")+
          name+LOG4CXX_STR("]."));
      activate = false;
   }
   activate &= asciiCheck(to, LOG4CXX_STR("to"));
   activate &= asciiCheck(cc, LOG4CXX_STR("cc"));
   activate &= asciiCheck(bcc, LOG4CXX_STR("bcc"));
   activate &= asciiCheck(from, LOG4CXX_STR("from"));
 
#if !LOG4CXX_HAVE_LIBESMTP
   errorHandler->error(LOG4CXX_STR("log4cxx built without SMTP support."));
   activate = false;
#endif     
   if (activate) {
        AppenderSkeleton::activateOptions(p);
   }
}

/**
Perform SMTPAppender specific appending actions, mainly adding
the event to a cyclic buffer and checking if the event triggers
an e-mail to be sent. */
void SMTPAppender::append(const spi::LoggingEventPtr& event, Pool& p)
{
   if(!checkEntryConditions())
   {
      return;
   }

   LogString ndc;
   event->getNDC(ndc);
   event->getThreadName();
   // Get a copy of this thread's MDC.
   event->getMDCCopy();

   cb.add(event);

   if(evaluator->isTriggeringEvent(event))
   {
      sendBuffer(p);
   }
}

/**
This method determines if there is a sense in attempting to append.
<p>It checks whether there is a set output target and also if
there is a set layout. If these checks fail, then the boolean
value <code>false</code> is returned. */
bool SMTPAppender::checkEntryConditions()
{
#if LOG4CXX_HAVE_LIBESMTP
   if((to.empty() && cc.empty() && bcc.empty()) || from.empty() || smtpHost.empty())
   {
      errorHandler->error(LOG4CXX_STR("Message not configured."));
      return false;
   }

   if(evaluator == 0)
   {
      errorHandler->error(LOG4CXX_STR("No TriggeringEventEvaluator is set for appender [")+
         name+ LOG4CXX_STR("]."));
      return false;
   }


   if(layout == 0)
   {
      errorHandler->error(LOG4CXX_STR("No layout set for appender named [")+name+LOG4CXX_STR("]."));
      return false;
   }
   return true;
#else
   return false;
#endif   
}



void SMTPAppender::close() {
   this->closed = true;
}

LogString SMTPAppender::getTo() const{
   return to;
}

void SMTPAppender::setTo(const LogString& addressStr) {
     to = addressStr;
}

LogString SMTPAppender::getCc() const{
   return cc;
}

void SMTPAppender::setCc(const LogString& addressStr) {
     cc = addressStr;
}

LogString SMTPAppender::getBcc() const{
   return bcc;
}

void SMTPAppender::setBcc(const LogString& addressStr) {
     bcc = addressStr;
}

/**
Send the contents of the cyclic buffer as an e-mail message.
*/
void SMTPAppender::sendBuffer(Pool& p)
{
#if LOG4CXX_HAVE_LIBESMTP
   // Note: this code already owns the monitor for this
   // appender. This frees us from needing to synchronize on 'cb'.
   try
   {
      LogString sbuf;
      layout->appendHeader(sbuf, p);

      int len = cb.length();
      for(int i = 0; i < len; i++)
      {
         LoggingEventPtr event = cb.get();
         layout->format(sbuf, event, p);
      }

      layout->appendFooter(sbuf, p);

      SMTPSession session(smtpHost, smtpPort, smtpUsername, smtpPassword, p);
      
      SMTPMessage message(session, from, to, cc, 
          bcc, subject, sbuf, p);
      
      session.send(p);

   }
   catch(std::exception& e)
   {
      LogLog::error(LOG4CXX_STR("Error occured while sending e-mail notification."), e);
   }
#endif   
}

/**
Returns value of the <b>EvaluatorClass</b> option.
*/
LogString SMTPAppender::getEvaluatorClass()
{
   return evaluator == 0 ? LogString() : evaluator->getClass().getName();
}

log4cxx::spi::TriggeringEventEvaluatorPtr SMTPAppender::getEvaluator() const {
   return evaluator;
}

void SMTPAppender::setEvaluator(log4cxx::spi::TriggeringEventEvaluatorPtr& trigger) {
    evaluator = trigger;
}

/**
The <b>BufferSize</b> option takes a positive integer
representing the maximum number of logging events to collect in a
cyclic buffer. When the <code>BufferSize</code> is reached,
oldest events are deleted as new events are added to the
buffer. By default the size of the cyclic buffer is 512 events.
*/
void SMTPAppender::setBufferSize(int sz)
{
   this->bufferSize = sz;
   cb.resize(sz);
}

/**
The <b>EvaluatorClass</b> option takes a string value
representing the name of the class implementing the {@link
TriggeringEventEvaluator} interface. A corresponding object will
be instantiated and assigned as the triggering event evaluator
for the SMTPAppender.
*/
void SMTPAppender::setEvaluatorClass(const LogString& value)
{
   evaluator = OptionConverter::instantiateByClassName(value,
      TriggeringEventEvaluator::getStaticClass(), evaluator);
}