src/adaptation/icap/Launcher.cc

   1 /*
   2  * DEBUG: section 93  ICAP (RFC 3507) Client
   3  */
   4
   5 #include "squid.h"
   6 #include "TextException.h"
   7 #include "HttpRequest.h"
   8 #include "HttpReply.h"
   9 #include "acl/FilledChecklist.h"
  10 #include "HttpMsg.h"
  11 #include "adaptation/icap/Launcher.h"
  12 #include "adaptation/icap/Xaction.h"
  13 #include "adaptation/icap/ServiceRep.h"
  14 #include "adaptation/icap/Config.h"
  15
  16
  17 Adaptation::Icap::Launcher::Launcher(const char *aTypeName,
  18                                      Adaptation::Initiator *anInitiator, Adaptation::ServicePointer &aService):
  19         AsyncJob(aTypeName),
  20         Adaptation::Initiate(aTypeName, anInitiator),
  21         theService(aService), theXaction(0), theLaunches(0)
  22 {
  23 }
  24
  25 Adaptation::Icap::Launcher::~Launcher()
  26 {
  27     assert(!theXaction);
  28 }
  29
  30 void Adaptation::Icap::Launcher::start()
  31 {
  32     Adaptation::Initiate::start();
  33
  34     Must(theInitiator);
  35     launchXaction("first");
  36 }
  37
  38 void Adaptation::Icap::Launcher::launchXaction(const char *xkind)
  39 {
  40     Must(!theXaction);
  41     ++theLaunches;
  42     debugs(93,4, HERE << "launching " << xkind << " xaction #" << theLaunches);
  43     Adaptation::Icap::Xaction *x = createXaction();
  44     x->attempts = theLaunches;
  45     if (theLaunches > 1)
  46         x->disableRetries();
  47     if (theLaunches >= TheConfig.repeat_limit)
  48         x->disableRepeats("over icap_retry_limit");
  49     theXaction = initiateAdaptation(x);
  50     Must(theXaction);
  51 }
  52
  53 void Adaptation::Icap::Launcher::noteAdaptationAnswer(HttpMsg *message)
  54 {
  55     sendAnswer(message);
  56     clearAdaptation(theXaction);
  57     Must(done());
  58     debugs(93,3, HERE << "Adaptation::Icap::Launcher::noteAdaptationAnswer exiting ");
  59 }
  60
  61 void Adaptation::Icap::Launcher::noteInitiatorAborted()
  62 {
  63
  64     announceInitiatorAbort(theXaction); // propogate to the transaction
  65     clearInitiator();
  66     Must(done()); // should be nothing else to do
  67
  68 }
  69
  70 // XXX: this call is unused by ICAPXaction in favor of ICAPLauncher::noteXactAbort
  71 void Adaptation::Icap::Launcher::noteAdaptationQueryAbort(bool final)
  72 {
  73     debugs(93,5, HERE << "launches: " << theLaunches << "; final: " << final);
  74     clearAdaptation(theXaction);
  75
  76     Must(done()); // swanSong will notify the initiator
  77 }
  78
  79 void Adaptation::Icap::Launcher::noteXactAbort(XactAbortInfo &info)
  80 {
  81     debugs(93,5, HERE << "theXaction:" << theXaction << " launches: " << theLaunches);
  82
  83     // TODO: add more checks from FwdState::checkRetry()?
  84     if (canRetry(info)) {
  85         clearAdaptation(theXaction);
  86         launchXaction("retry");
  87     } else if (canRepeat(info)) {
  88         clearAdaptation(theXaction);
  89         launchXaction("repeat");
  90     } else {
  91         debugs(93,3, HERE << "cannot retry or repeat a failed transaction");
  92         clearAdaptation(theXaction);
  93         tellQueryAborted(false); // caller decides based on bypass, consumption
  94         Must(done());
  95     }
  96 }
  97
  98 bool Adaptation::Icap::Launcher::doneAll() const
  99 {
 100     return (!theInitiator || !theXaction) && Adaptation::Initiate::doneAll();
 101 }
 102
 103 void Adaptation::Icap::Launcher::swanSong()
 104 {
 105     if (theInitiator)
 106         tellQueryAborted(true); // always final here because abnormal
 107
 108     if (theXaction)
 109         clearAdaptation(theXaction);
 110
 111     Adaptation::Initiate::swanSong();
 112 }
 113
 114 bool Adaptation::Icap::Launcher::canRetry(Adaptation::Icap::XactAbortInfo &info) const
 115 {
 116     // We do not check and can exceed zero repeat limit when retrying.
 117     // This is by design as the limit does not apply to pconn retrying.
 118     return !shutting_down && info.isRetriable;
 119 }
 120
 121 bool Adaptation::Icap::Launcher::canRepeat(Adaptation::Icap::XactAbortInfo &info) const
 122 {
 123     debugs(93,9, HERE << shutting_down);
 124     if (theLaunches >= TheConfig.repeat_limit || shutting_down)
 125         return false;
 126
 127     debugs(93,9, HERE << info.isRepeatable); // TODO: update and use status()
 128     if (!info.isRepeatable)
 129         return false;
 130
 131     debugs(93,9, HERE << info.icapReply);
 132     if (!info.icapReply) // did not get to read an ICAP reply; a timeout?
 133         return true;
 134
 135     debugs(93,9, HERE << info.icapReply->sline.status);
 136     if (!info.icapReply->sline.status) // failed to parse the reply; I/O err
 137         return true;
 138
 139     ACLFilledChecklist *cl =
 140         new ACLFilledChecklist(TheConfig.repeat, info.icapRequest, dash_str);
 141     cl->reply = HTTPMSGLOCK(info.icapReply);
 142
 143     const bool result = cl->fastCheck();
 144     delete cl;
 145     return result;
 146 }
 147
 148 /* ICAPXactAbortInfo */
 149
 150 Adaptation::Icap::XactAbortInfo::XactAbortInfo(HttpRequest *anIcapRequest,
 151         HttpReply *anIcapReply, bool beRetriable, bool beRepeatable):
 152         icapRequest(anIcapRequest ? HTTPMSGLOCK(anIcapRequest) : NULL),
 153         icapReply(anIcapReply ? HTTPMSGLOCK(anIcapReply) : NULL),
 154         isRetriable(beRetriable), isRepeatable(beRepeatable)
 155 {
 156 }
 157
 158 Adaptation::Icap::XactAbortInfo::XactAbortInfo(const Adaptation::Icap::XactAbortInfo &i):
 159         icapRequest(i.icapRequest ? HTTPMSGLOCK(i.icapRequest) : NULL),
 160         icapReply(i.icapReply ? HTTPMSGLOCK(i.icapReply) : NULL),
 161         isRetriable(i.isRetriable), isRepeatable(i.isRepeatable)
 162 {
 163 }
 164
 165 Adaptation::Icap::XactAbortInfo::~XactAbortInfo()
 166 {
 167     HTTPMSGUNLOCK(icapRequest);
 168     HTTPMSGUNLOCK(icapReply);
 169 }