src/adaptation/icap/Xaction.h

   1
   2 /*
   3  * $Id$
   4  *
   5  *
   6  * SQUID Web Proxy Cache          http://www.squid-cache.org/
   7  * ----------------------------------------------------------
   8  *
   9  *  Squid is the result of efforts by numerous individuals from
  10  *  the Internet community; see the CONTRIBUTORS file for full
  11  *  details.   Many organizations have provided support for Squid's
  12  *  development; see the SPONSORS file for full details.  Squid is
  13  *  Copyrighted (C) 2001 by the Regents of the University of
  14  *  California; see the COPYRIGHT file for full details.  Squid
  15  *  incorporates software developed and/or copyrighted by other
  16  *  sources; see the CREDITS file for full details.
  17  *
  18  *  This program is free software; you can redistribute it and/or modify
  19  *  it under the terms of the GNU General Public License as published by
  20  *  the Free Software Foundation; either version 2 of the License, or
  21  *  (at your option) any later version.
  22  *
  23  *  This program is distributed in the hope that it will be useful,
  24  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  25  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  26  *  GNU General Public License for more details.
  27  *
  28  *  You should have received a copy of the GNU General Public License
  29  *  along with this program; if not, write to the Free Software
  30  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111, USA.
  31  *
  32  */
  33
  34 #ifndef SQUID_ICAPXACTION_H
  35 #define SQUID_ICAPXACTION_H
  36
  37 #include "comm.h"
  38 #include "CommCalls.h"
  39 #include "MemBuf.h"
  40 #include "adaptation/icap/ServiceRep.h"
  41 #include "adaptation/Initiate.h"
  42 #include "AccessLogEntry.h"
  43 #include "HttpReply.h"
  44
  45 class CommConnectCbParams;
  46
  47 namespace Adaptation
  48 {
  49 namespace Icap
  50 {
  51
  52 /*
  53  * The ICAP Xaction implements common tasks for ICAP OPTIONS, REQMOD, and
  54  * RESPMOD transactions. It is started by an Initiator. It terminates
  55  * on its own, when done. Transactions communicate with Initiator using
  56  * asynchronous messages because a transaction or Initiator may be gone at
  57  * any time.
  58  */
  59
  60 // Note: Xaction must be the first parent for object-unaware cbdata to work
  61
  62 class Xaction: public Adaptation::Initiate
  63 {
  64
  65 public:
  66     Xaction(const char *aTypeName, ServiceRep::Pointer &aService);
  67     virtual ~Xaction();
  68
  69     void disableRetries();
  70     void disableRepeats(const char *reason);
  71     bool retriable() const { return isRetriable; }
  72     bool repeatable() const { return isRepeatable; }
  73
  74     // comm handler wrappers, treat as private
  75     void noteCommConnected(const CommConnectCbParams &io);
  76     void noteCommWrote(const CommIoCbParams &io);
  77     void noteCommRead(const CommIoCbParams &io);
  78     void noteCommTimedout(const CommTimeoutCbParams &io);
  79     void noteCommClosed(const CommCloseCbParams &io);
  80
  81     // TODO: create these only when actually sending/receiving
  82     HttpRequest *icapRequest; ///< sent (or at least created) ICAP request
  83     HttpReply::Pointer icapReply; ///< received ICAP reply, if any
  84
  85     /// the number of times we tried to get to the service, including this time
  86     int attempts;
  87
  88 protected:
  89     virtual void start();
  90     virtual void noteInitiatorAborted(); // TODO: move to Adaptation::Initiate
  91
  92     // comm hanndlers; called by comm handler wrappers
  93     virtual void handleCommConnected() = 0;
  94     virtual void handleCommWrote(size_t sz) = 0;
  95     virtual void handleCommRead(size_t sz) = 0;
  96     virtual void handleCommTimedout();
  97     virtual void handleCommClosed();
  98
  99     /// record error detail if possible
 100     virtual void detailError(int errDetail) {}
 101
 102     void openConnection();
 103     void closeConnection();
 104     void dieOnConnectionFailure();
 105
 106     void scheduleRead();
 107     void scheduleWrite(MemBuf &buf);
 108     void updateTimeout();
 109
 110     void cancelRead();
 111
 112     bool parseHttpMsg(HttpMsg *msg); // true=success; false=needMore; throw=err
 113     bool mayReadMore() const;
 114
 115     virtual bool doneReading() const;
 116     virtual bool doneWriting() const;
 117     bool doneWithIo() const;
 118     virtual bool doneAll() const;
 119
 120     // called just before the 'done' transaction is deleted
 121     virtual void swanSong();
 122
 123     // returns a temporary string depicting transaction status, for debugging
 124     virtual const char *status() const;
 125     virtual void fillPendingStatus(MemBuf &buf) const;
 126     virtual void fillDoneStatus(MemBuf &buf) const;
 127
 128     // useful for debugging
 129     virtual bool fillVirginHttpHeader(MemBuf&) const;
 130
 131 public:
 132     // custom exception handling and end-of-call checks
 133     virtual void callException(const std::exception  &e);
 134     virtual void callEnd();
 135
 136 protected:
 137     // logging
 138     void setOutcome(const XactOutcome &xo);
 139     virtual void finalizeLogInfo();
 140
 141 public:
 142     ServiceRep &service();
 143
 144 private:
 145     void tellQueryAborted();
 146     void maybeLog();
 147
 148 protected:
 149     int connection;     // FD of the ICAP server connection
 150     Adaptation::Icap::ServiceRep::Pointer theService;
 151
 152     /*
 153      * We have two read buffers.   We would prefer to read directly
 154      * into the MemBuf, but since comm_read isn't MemBuf-aware, and
 155      * uses event-delayed callbacks, it leaves the MemBuf in an
 156      * inconsistent state.  There would be data in the buffer, but
 157      * MemBuf.size won't be updated until the (delayed) callback
 158      * occurs.   To avoid that situation we use a plain buffer
 159      * (commBuf) and then copy (append) its contents to readBuf in
 160      * the callback.  If comm_read ever becomes MemBuf-aware, we
 161      * can eliminate commBuf and this extra buffer copy.
 162      */
 163     MemBuf readBuf;
 164     char *commBuf;
 165     size_t commBufSize;
 166     bool commEof;
 167     bool reuseConnection;
 168     bool isRetriable;  ///< can retry on persistent connection failures
 169     bool isRepeatable; ///< can repeat if no or unsatisfactory response
 170     bool ignoreLastWrite;
 171
 172     const char *stopReason;
 173
 174     // active (pending) comm callbacks for the ICAP server connection
 175     AsyncCall::Pointer connector;
 176     AsyncCall::Pointer reader;
 177     AsyncCall::Pointer writer;
 178     AsyncCall::Pointer closer;
 179
 180     AccessLogEntry al;
 181
 182     timeval icap_tr_start;     /*time when the ICAP transaction was created */
 183     timeval icap_tio_start;    /*time when the first ICAP request byte was scheduled for sending*/
 184     timeval icap_tio_finish;   /*time when the last byte of the ICAP responsewas received*/
 185
 186 private:
 187     //CBDATA_CLASS2(Xaction);
 188 };
 189
 190
 191 } // namespace Icap
 192 } // namespace Adaptation
 193
 194 #endif /* SQUID_ICAPXACTION_H */