---------------------
PatchSet 4714 
Date: 2002/08/19 00:12:59
Author: rbcollins
Branch: esi
Tag: (none) 
Log:
3.4 try attempt except

Members: 
	src/ESI.c:1.1.2.14->1.1.2.15 

Index: squid/src/ESI.c
===================================================================
RCS file: /cvsroot/squid-sf//squid/src/Attic/ESI.c,v
retrieving revision 1.1.2.14
retrieving revision 1.1.2.15
diff -u -r1.1.2.14 -r1.1.2.15
--- squid/src/ESI.c	18 Aug 2002 13:25:15 -0000	1.1.2.14
+++ squid/src/ESI.c	19 Aug 2002 00:12:59 -0000	1.1.2.15
@@ -1,6 +1,6 @@
 
 /*
- * $Id: ESI.c,v 1.1.2.14 2002/08/18 13:25:15 rbcollins Exp $
+ * $Id: ESI.c,v 1.1.2.15 2002/08/19 00:12:59 rbcollins Exp $
  *
  * DEBUG: section 86    ESI processing
  * AUTHOR: Robert Collins
@@ -85,7 +85,6 @@
 /* TODO: remove invalid markup (silently swallow markup in invalid locations
  * TODO: inline variables
  * TODO: 3.3 choose when otherwise
- * TODO: 3.4 try attempt except
  * TODO: 3.7 vars
  *
  *
@@ -144,12 +143,19 @@
 static esiRender esiRemoveRender;
 static esiAddElement esiRemoveAdd;
 
+esiAddElement esiTryAdd;
+static esiRender esiTryRender;
+static esiProcessSelf esiTryProcess;
+
 /* the types we have */
 typedef enum {
     ESI_ELEMENT_NONE,
     ESI_ELEMENT_INCLUDE,
     ESI_ELEMENT_COMMENT,
-    ESI_ELEMENT_REMOVE
+    ESI_ELEMENT_REMOVE,
+    ESI_ELEMENT_TRY,
+    ESI_ELEMENT_ATTEMPT,
+    ESI_ELEMENT_EXCEPT
 } esiElementType_t;
 
 static esiElementType _esiComment  = {esiCommentRender,esiAddFail,esiProcessComplete};
@@ -157,6 +163,10 @@
 static esiElementType _esiSequence = {esiSequenceRender,esiSequenceAdd,esiSequenceProcess};
 static esiElementType _esiInclude  = {esiIncludeRender, esiAddFail, esiIncludeProcess};
 static esiElementType _esiRemove   = {esiRemoveRender, esiRemoveAdd, esiProcessComplete};
+static esiElementType _esiTry      = {esiTryRender, esiTryAdd, esiTryProcess};
+/* esiAttempt and esiExcept are 'Sequences' */
+static esiElementType _esiAttempt  = {esiSequenceRender,esiSequenceAdd,esiSequenceProcess};
+static esiElementType _esiExcept   = {esiSequenceRender,esiSequenceAdd,esiSequenceProcess};
 
 /* esiComment */
 typedef struct {
@@ -210,12 +220,37 @@
 
 /* esiRemove */
 typedef struct {
-        esiElementType *vptr;
+    esiElementType *vptr;
 } esiRemove;
 CBDATA_TYPE (esiRemove);
 static FREE esiRemoveFree;
 static esiElement * esiRemoveNew(void);
 
+/* esiAttempt */
+typedef esiSequence esiAttempt;
+static esiElement *esiAttemptNew(void);
+
+/* esiExcept */
+typedef esiSequence esiExcept;
+static esiElement *esiExceptNew(void);
+
+/* esiTry */
+typedef struct {
+    esiElementType *vptr;
+    esiElement *attempt;
+    esiElement *except;
+    struct {
+	int attemptok:1; /* the attempt branch process correctly */
+	int exceptok:1; /* likewise */
+	int attemptfailed:1; /* The attempt branch failed */
+	int exceptfailed:1; /* the except branch failed */
+    } flags;
+} esiTry;
+CBDATA_TYPE (esiTry);
+static FREE esiTryFree;
+static esiElement *esiTryNew(void);
+
+/* esiContext */
 struct _esiContext {
     clientStreamNode *this; /* our stream node */
     clientHttpRequest *http; /* the request we are processing. HMM: cbdataReferencing this will result
@@ -285,6 +320,7 @@
 /* static void esiStartSub (void); */
 static void esiFail (clientStreamNode *this, esiContext *context, clientHttpRequest *http);
 static esiKick_t esiKick (esiContext *context);
+static void esiAddStackElement (esiContext *context, esiElement *element);
 
 /* ESI TO CONSIDER:
  * 1. retry failed upstream requests
@@ -733,16 +769,38 @@
     assert (el);
     if (strlen (el) < 5 || strncmp (el, "esi:", 4))
 	return ESI_ELEMENT_NONE;
-    if (!strncmp (el + 4, "comment",7))
+    if (!strncmp (el + 4, "comment", 7))
 	return ESI_ELEMENT_COMMENT;
-    if (!strncmp (el + 4, "include",7))
+    if (!strncmp (el + 4, "include", 7))
 	return ESI_ELEMENT_INCLUDE;
-    if (!strncmp (el + 4, "remove",6))
+    if (!strncmp (el + 4, "attempt", 7))
+	return ESI_ELEMENT_ATTEMPT;
+    if (!strncmp (el + 4, "remove", 6))
 	return ESI_ELEMENT_REMOVE;
+    if (!strncmp (el + 4, "except", 6))
+	return ESI_ELEMENT_EXCEPT;
+    if (!strncmp (el + 4, "try", 3))
+	return ESI_ELEMENT_TRY;
+    
     return ESI_ELEMENT_NONE;
 }
 
 void
+esiAddStackElement (esiContext *context, esiElement *element)
+{
+    /* Put on the stack to allow skipping of 'invalid' markup */
+    assert (context->parserState.stackdepth <11);
+    if (ADDELEMENT (context->parserState.stack[context->parserState.stackdepth-1], element)) {
+	debug (86,1)("esiProcess: failed to add esi node, probable error in ESI template\n");
+	context->flags.error = 1;
+	cbdataFree (element);
+    } else {
+	/* added ok, push onto the stack */
+	context->parserState.stack[context->parserState.stackdepth++] = element;
+    }
+}
+
+void
 start(void *data,const XML_Char *el, const char **attr) 
 {
     int i;
@@ -788,49 +846,35 @@
 	break;
       case ESI_ELEMENT_COMMENT:
 	/* Put on the stack to allow skipping of 'invalid' markup */
-	assert (context->parserState.stackdepth <11);
 	element = esiCommentNew ();
-	if (ADDELEMENT (context->parserState.stack[context->parserState.stackdepth-1], element)) {
-	    debug (86,1)("esiProcess: failed to add esi node, probable error in ESI template\n");
-	    context->flags.error = 1;
-	    cbdataFree (element);
-	    
-	    break;
-	} else {
-	    /* added ok, push onto the stack */
-	    context->parserState.stack[context->parserState.stackdepth++] = element;
-	}
+	esiAddStackElement (context, element);
 	break;
       case ESI_ELEMENT_INCLUDE:
 	/* Put on the stack to allow skipping of 'invalid' markup */
-	assert (context->parserState.stackdepth <11);
 	element = esiIncludeNew (specifiedattcount, attr, context);
-	if (ADDELEMENT (context->parserState.stack[context->parserState.stackdepth-1], element)) {
-	    debug (86,1)("esiProcess: failed to add esi node, probable error in ESI template\n");
-	    context->flags.error = 1;
-	    cbdataFree (element);
-	    break;
-	} else {
-	    /* added ok, push onto the stack */
-	    context->parserState.stack[context->parserState.stackdepth++] = element;
-	}
+	esiAddStackElement (context, element);
 	break;
       case ESI_ELEMENT_REMOVE:
 	/* Put on the stack to allow skipping of 'invalid' markup */
-	assert (context->parserState.stackdepth <11);
 	element = esiRemoveNew ();
-	if (ADDELEMENT (context->parserState.stack[context->parserState.stackdepth-1], element)) {
-	    debug (86,1)("esiProcess: failed to add esi node, probable error in ESI template\n");
-	    context->flags.error = 1;
-	    cbdataFree (element);
-	    break;
-	} else {
-	    /* added ok, push onto the stack */
-	    context->parserState.stack[context->parserState.stackdepth++] = element;
-	}
+	esiAddStackElement (context, element);
+	break;
+      case ESI_ELEMENT_TRY:
+	/* Put on the stack to allow skipping of 'invalid' markup */
+	element = esiTryNew ();
+	esiAddStackElement (context, element);
+	break;
+      case ESI_ELEMENT_ATTEMPT:
+	/* Put on the stack to allow skipping of 'invalid' markup */
+	element = esiAttemptNew ();
+	esiAddStackElement (context, element);
+	break;	
+      case ESI_ELEMENT_EXCEPT:
+	/* Put on the stack to allow skipping of 'invalid' markup */
+	element = esiExceptNew ();
+	esiAddStackElement (context, element);
 	break;
     }
-   
 
     debug (86,5)("esi stack depth %d\n",context->parserState.stackdepth);
     
@@ -865,6 +909,9 @@
       case ESI_ELEMENT_COMMENT:
       case ESI_ELEMENT_INCLUDE:
       case ESI_ELEMENT_REMOVE:
+      case ESI_ELEMENT_TRY:
+      case ESI_ELEMENT_ATTEMPT:
+      case ESI_ELEMENT_EXCEPT:
 	/* pop of the stack */
 	--context->parserState.stackdepth;
 	break;
@@ -888,7 +935,7 @@
     esiContext *context = XML_GetUserData(parser);
     if (!strncmp(s, "esi",3)) {
 	XML_Parser p;
-	debug (86,1)("esiExpatComment: ESI <!-- block encountered\n");
+	debug (86,5)("esiExpatComment: ESI <!-- block encountered\n");
 	/* TODO: pass this to ?? another ?? expat parser? Guess so. */
 	p = XML_ParserCreate(NULL);
 	XML_SetUserData (p, context);
@@ -911,12 +958,12 @@
 	}
 	assert (XML_Parse (p, "</div>",6,1));
 	XML_ParserFree (p);
-	debug (86,1)("esiExpatComment: ESI <!-- block parsed\n");
+	debug (86,5)("esiExpatComment: ESI <!-- block parsed\n");
 	return;
     } else {
 	char localbuf [HTTP_REQBUF_SZ];
 	int len;
-	debug (86,1)("esiExpatComment: Regenerating comment block\n");
+	debug (86,5)("esiExpatComment: Regenerating comment block\n");
 	len = strlen (s);
 	if (len > sizeof (localbuf) - 9) {
 	    debug (86,0)("esiExpatComment: Truncating long comment\n");
@@ -1433,6 +1480,12 @@
 {
     /* add an element to the output list */
     esiSequence *this = data;
+    /* Some elements require specific parents */
+    if (element->vptr == &_esiAttempt || 
+	element->vptr == &_esiExcept) {
+	debug (86,0)("esiSequenceAdd: misparented Attempt or Except element (section 3.4)\n");
+	return -1;
+    }
     this->elements = memReallocBuf (this->elements, ++this->elementcount * sizeof (esiElement *),
 				    &this->allocedsize);
     assert (this->elements);
@@ -1693,7 +1746,8 @@
 
 /* Accept non-ESI children */
 int
-esiRemoveAdd (void *data, esiElement *element) {
+esiRemoveAdd (void *data, esiElement *element)
+{
     if (element->vptr != & _esiLiteral) {
 	debug (86,5)("esiRemoveAdd: Failed for %p\n",data);
 	return -1;
@@ -1701,4 +1755,154 @@
     return 0;
 }
 
+/* esiTry */
+void
+esiTryFree (void *data)
+{
+    esiTry *this = data;
+    debug (86,5)("esiTryFree %p\n", this);
+    cbdataFree (this->attempt);
+    cbdataFree (this->except);
+}
+
+esiElement *
+esiTryNew ()
+{
+    esiTry *rv;
+    CBDATA_INIT_TYPE_FREECB(esiTry, esiTryFree);
+    rv = cbdataAlloc (esiTry);
+    rv->vptr = &_esiTry;
+    return (esiElement *) rv;
+}
+
+void
+esiTryRender (void *data, esiSegment *output)
+{
+    /* Try renders from it's children */
+    esiTry *this = data;
+    assert (this);
+    assert (this->attempt);
+    assert (this->except);
+    debug (86, 5)("esiTryRender: Rendering Try %p\n", data);
+    if (this->flags.attemptok) {
+	RENDER (this->attempt, output);
+    } else if (this->flags.exceptok) {
+	RENDER (this->except, output);
+    } else
+	debug (86,5)("esiTryRender: Neither except nor attempt succeeded?!?\n");
+}
+
+/* Accept attempt and except only */
+int
+esiTryAdd (void *data, esiElement *element)
+{
+    esiTry *this = data;
+    debug (86,5)("esiTryAdd: Try %p adding element %p\n",this, element);
+    if (element->vptr == &_esiLiteral) {
+	/* Swallow whitespace */
+	debug (86,5)("esiTryAdd: Try %p skipping whitespace %p\n",this, element);
+	cbdataFree (element);
+	return 0;
+    }
+    if (element->vptr == &_esiAttempt) {
+	if (this->attempt) {
+	    debug (86,1)("esiTryAdd: Failed for %p - try allready has an attempt node (section 3.4)\n",data);
+	    return -1;
+	}
+	this->attempt = element;
+	return 0;
+    }
+    if (element->vptr == &_esiExcept) {
+	if (this->except) {
+	    debug (86,1)("esiTryAdd: Failed for %p - try already has an except node (section 3.4)\n",data);
+	    return -1;
+	}
+	this->except = element;
+	return 0;
+    }
+    debug (86,1)("esiTryAdd: Failed to add element %p to try %p, incorrect element type (see section 3.4)\n", element, this);
+    return -1;
+}
+           
+esiProcessResult_t
+esiTryProcess (void *data)
+{
+    esiTry *this = data;
+    esiProcessResult_t rv = ESI_PROCESS_PENDING_MAYFAIL;
+    assert (this);
+    if (!this->attempt) {
+	debug (86,0)("esiTryProcess: Try has no attempt element - ESI template is invalid (section 3.4)\n");
+	return ESI_PROCESS_FAILED;
+    }
+    if (!this->except) {
+	debug (86,0)("esiTryProcess: Try has no except element - ESI template is invalid (section 3.4)\n");
+	return ESI_PROCESS_FAILED;
+    }
+    if (!this->flags.attemptfailed)
+	/* Try the attempt branch */
+	switch ((rv = PROCESS(this->attempt))){
+	  case ESI_PROCESS_COMPLETE:
+	    debug (86,5)("esiTryProcess: attempt Processed OK\n");
+	    this->flags.attemptok = 1;
+	    return ESI_PROCESS_COMPLETE;
+	  case ESI_PROCESS_PENDING_WONTFAIL:
+	    debug (86,5)("esiTryProcess: attempt Processed PENDING OK\n");
+	    /* We're not done yet, but don't need to test except */
+	    return ESI_PROCESS_PENDING_WONTFAIL;
+	  case ESI_PROCESS_PENDING_MAYFAIL:
+	    debug (86,5)("eseSequenceProcess: element Processed PENDING UNKNOWN\n");
+	    break;
+	  case ESI_PROCESS_FAILED:
+	    debug (86,5)("esiSequenceProcess: elemen Processed FAILED\n");
+	    this->flags.attemptfailed = 1;
+	    break;
+	}
+    /* attempt is either MAYFAIL or FAILED */
+    /* query except to see if it has a definite result */
+    if (!this->flags.exceptfailed)
+	/* Try the except branch */
+	switch (PROCESS(this->except)){
+	  case ESI_PROCESS_COMPLETE:
+	    debug (86,5)("esiTryProcess: except Processed OK\n");
+	    this->flags.exceptok = 1;
+	    if (this->flags.attemptfailed)
+		return ESI_PROCESS_COMPLETE;
+	    else
+		return ESI_PROCESS_PENDING_MAYFAIL;
+	  case ESI_PROCESS_PENDING_WONTFAIL:
+	    debug (86,5)("esiTryProcess: attempt Processed PENDING OK\n");
+	    /* We're not done yet, but can't fail */
+	    return ESI_PROCESS_PENDING_WONTFAIL;
+	  case ESI_PROCESS_PENDING_MAYFAIL:
+	    debug (86,5)("eseSequenceProcess: element Processed PENDING UNKNOWN\n");
+	    /* The except branch fail fail */
+	    return ESI_PROCESS_PENDING_MAYFAIL;
+	  case ESI_PROCESS_FAILED:
+	    debug (86,5)("esiSequenceProcess: element Processed FAILED\n");
+	    this->flags.exceptfailed = 1;
+	    break;
+	}
+
+    if (this->flags.exceptfailed && this->flags.attemptfailed)
+	return ESI_PROCESS_FAILED;
+    /* one of attempt or except returned PENDING MAYFAIL */
+    return ESI_PROCESS_PENDING_MAYFAIL;
+}
+
+/* esiAttempt */
+esiElement *
+esiAttemptNew ()
+{
+    esiElement *rv = esiSequenceNew();
+    rv->vptr = &_esiAttempt;
+    return rv;
+}
 
+/* esiExcept */
+esiElement *
+esiExceptNew ()
+{
+    esiElement *rv = esiSequenceNew();
+    rv->vptr = &_esiExcept;
+    return rv;
+}