trafficserver-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From iga...@apache.org
Subject svn commit: r1068147 - /trafficserver/traffic/trunk/proxy/http/
Date Mon, 07 Feb 2011 21:38:12 GMT
Author: igalic
Date: Mon Feb  7 21:38:11 2011
New Revision: 1068147

URL: http://svn.apache.org/viewvc?rev=1068147&view=rev
Log:
[TS-665] Remove HTTP_ASSERT() and HTTP_DEBUG_ASSERT()

Removed:
    trafficserver/traffic/trunk/proxy/http/HttpAssert.h
Modified:
    trafficserver/traffic/trunk/proxy/http/HttpAccept.cc
    trafficserver/traffic/trunk/proxy/http/HttpClientSession.cc
    trafficserver/traffic/trunk/proxy/http/HttpConfig.cc
    trafficserver/traffic/trunk/proxy/http/HttpConfig.h
    trafficserver/traffic/trunk/proxy/http/HttpMessageBody.cc
    trafficserver/traffic/trunk/proxy/http/HttpProxyServerMain.cc
    trafficserver/traffic/trunk/proxy/http/HttpSM.cc
    trafficserver/traffic/trunk/proxy/http/HttpTransact.cc
    trafficserver/traffic/trunk/proxy/http/HttpTransact.h
    trafficserver/traffic/trunk/proxy/http/HttpTransactHeaders.cc
    trafficserver/traffic/trunk/proxy/http/HttpTransactHeaders.h
    trafficserver/traffic/trunk/proxy/http/Makefile.am

Modified: trafficserver/traffic/trunk/proxy/http/HttpAccept.cc
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/proxy/http/HttpAccept.cc?rev=1068147&r1=1068146&r2=1068147&view=diff
==============================================================================
--- trafficserver/traffic/trunk/proxy/http/HttpAccept.cc (original)
+++ trafficserver/traffic/trunk/proxy/http/HttpAccept.cc Mon Feb  7 21:38:11 2011
@@ -23,7 +23,6 @@
 
 #include "HttpAccept.h"
 #include "IPAllow.h"
-#include "HttpAssert.h"
 #include "HttpClientSession.h"
 #include "I_Machine.h"
 

Modified: trafficserver/traffic/trunk/proxy/http/HttpClientSession.cc
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/proxy/http/HttpClientSession.cc?rev=1068147&r1=1068146&r2=1068147&view=diff
==============================================================================
--- trafficserver/traffic/trunk/proxy/http/HttpClientSession.cc (original)
+++ trafficserver/traffic/trunk/proxy/http/HttpClientSession.cc Mon Feb  7 21:38:11 2011
@@ -38,7 +38,7 @@
 #include "HttpServerSession.h"
 
 #define STATE_ENTER(state_name, event, vio) { \
-    /*HTTP_DEBUG_ASSERT (magic == HTTP_SM_MAGIC_ALIVE);  REMEMBER (event, NULL, reentrancy_count); */ \
+    /*ink_debug_assert (magic == HTTP_SM_MAGIC_ALIVE);  REMEMBER (event, NULL, reentrancy_count); */ \
         Debug("http_cs", "[%" PRId64 "] [%s, %s]", con_id, \
         #state_name, HttpDebugNames::get_event_name(event)); }
 

Modified: trafficserver/traffic/trunk/proxy/http/HttpConfig.cc
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/proxy/http/HttpConfig.cc?rev=1068147&r1=1068146&r2=1068147&view=diff
==============================================================================
--- trafficserver/traffic/trunk/proxy/http/HttpConfig.cc (original)
+++ trafficserver/traffic/trunk/proxy/http/HttpConfig.cc Mon Feb  7 21:38:11 2011
@@ -1994,7 +1994,7 @@ HttpConfig::parse_ports_list(char *ports
 
       start = end;
 
-      HTTP_ASSERT(pr->low <= pr->high);
+      ink_release_assert(pr->low <= pr->high);
     }
   }
   return (ports_list);

Modified: trafficserver/traffic/trunk/proxy/http/HttpConfig.h
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/proxy/http/HttpConfig.h?rev=1068147&r1=1068146&r2=1068147&view=diff
==============================================================================
--- trafficserver/traffic/trunk/proxy/http/HttpConfig.h (original)
+++ trafficserver/traffic/trunk/proxy/http/HttpConfig.h Mon Feb  7 21:38:11 2011
@@ -55,8 +55,6 @@
 #define MgmtInt RecInt
 #define MgmtFloat RecFloat
 
-#include "HttpAssert.h"
-
 
 #include "P_RecProcess.h"
 

Modified: trafficserver/traffic/trunk/proxy/http/HttpMessageBody.cc
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/proxy/http/HttpMessageBody.cc?rev=1068147&r1=1068146&r2=1068147&view=diff
==============================================================================
--- trafficserver/traffic/trunk/proxy/http/HttpMessageBody.cc (original)
+++ trafficserver/traffic/trunk/proxy/http/HttpMessageBody.cc Mon Feb  7 21:38:11 2011
@@ -24,7 +24,6 @@
 #include "ink_unused.h"  /* MAGIC_EDITING_TAG */
 #include "HttpMessageBody.h"
 #include "HttpConfig.h"
-#include "HttpAssert.h"
 
 /** This routine returns a constant string name for the status_code. */
 const char *
@@ -121,7 +120,7 @@ HttpMessageBody::MakeErrorBodyVA(int64_t
     l++;                        // leave room for trailing NUL
 
     if (pass == 2) {
-      HTTP_ASSERT(l == output_length);
+      ink_release_assert(l == output_length);
     }
     output_length = l;
   }

Modified: trafficserver/traffic/trunk/proxy/http/HttpProxyServerMain.cc
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/proxy/http/HttpProxyServerMain.cc?rev=1068147&r1=1068146&r2=1068147&view=diff
==============================================================================
--- trafficserver/traffic/trunk/proxy/http/HttpProxyServerMain.cc (original)
+++ trafficserver/traffic/trunk/proxy/http/HttpProxyServerMain.cc Mon Feb  7 21:38:11 2011
@@ -266,7 +266,7 @@ start_HttpProxyServer(int fd, int port, 
         HttpStateMachine::m_state_machines_max_count =
             atoi(state_machines_max_count);
 
-        HTTP_ASSERT (HttpStateMachine::m_state_machines_max_count >= 1);
+        ink_release_assert (HttpStateMachine::m_state_machines_max_count >= 1);
     }
     */
   ///////////////////////////////////

Modified: trafficserver/traffic/trunk/proxy/http/HttpSM.cc
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/proxy/http/HttpSM.cc?rev=1068147&r1=1068146&r2=1068147&view=diff
==============================================================================
--- trafficserver/traffic/trunk/proxy/http/HttpSM.cc (original)
+++ trafficserver/traffic/trunk/proxy/http/HttpSM.cc Mon Feb  7 21:38:11 2011
@@ -293,7 +293,7 @@ history[pos].fileline = __FILE__ ":" _RE
 #undef STATE_ENTER
 #endif
 #define STATE_ENTER(state_name, event) { \
-    /*HTTP_DEBUG_ASSERT (magic == HTTP_SM_MAGIC_ALIVE); */ REMEMBER (event, reentrancy_count);  \
+    /*ink_debug_assert (magic == HTTP_SM_MAGIC_ALIVE); */ REMEMBER (event, reentrancy_count);  \
         Debug("http", "[%" PRId64 "] [%s, %s]", sm_id, \
         #state_name, HttpDebugNames::get_event_name(event)); }
 
@@ -2072,7 +2072,7 @@ HttpSM::state_hostdb_lookup(int event, v
 {
   STATE_ENTER(&HttpSM::state_hostdb_lookup, event);
 
-//    HTTP_DEBUG_ASSERT (m_origin_server_vc == 0);
+//    ink_debug_assert (m_origin_server_vc == 0);
   // REQ_FLAVOR_SCHEDULED_UPDATE can be transformed into
   // REQ_FLAVOR_REVPROXY
   ink_assert(t_state.req_flavor == HttpTransact::REQ_FLAVOR_SCHEDULED_UPDATE ||
@@ -6130,7 +6130,7 @@ HttpSM::update_stats()
     if (t_state.hdr_info.client_response.valid() && t_state.hdr_info.client_response.status_get() == HTTP_STATUS_OK) {
       int64_t p_resp_cl = t_state.hdr_info.client_response.get_content_length();
       int64_t resp_size = client_response_body_bytes;
-      HTTP_ASSERT(p_resp_cl == -1 || p_resp_cl == resp_size || resp_size == 0);
+      ink_release_assert(p_resp_cl == -1 || p_resp_cl == resp_size || resp_size == 0);
     }
   }
 
@@ -6685,7 +6685,7 @@ HttpSM::set_next_state()
     {
       HTTP_SM_SET_DEFAULT_HANDLER(&HttpSM::state_mark_os_down);
 
-      HTTP_DEBUG_ASSERT(t_state.dns_info.looking_up == HttpTransact::ORIGIN_SERVER);
+      ink_debug_assert(t_state.dns_info.looking_up == HttpTransact::ORIGIN_SERVER);
       do_hostdb_lookup();
       break;
     }

Modified: trafficserver/traffic/trunk/proxy/http/HttpTransact.cc
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/proxy/http/HttpTransact.cc?rev=1068147&r1=1068146&r2=1068147&view=diff
==============================================================================
--- trafficserver/traffic/trunk/proxy/http/HttpTransact.cc (original)
+++ trafficserver/traffic/trunk/proxy/http/HttpTransact.cc Mon Feb  7 21:38:11 2011
@@ -44,7 +44,6 @@
 #include "CacheControl.h"
 #include "ControlMatcher.h"
 #include "ReverseProxy.h"
-#include "HttpAssert.h"
 #include "HttpBodyFactory.h"
 #include "StatPages.h"
 #include "HttpClientSession.h"
@@ -350,7 +349,7 @@ find_server_and_update_current_info(Http
     s->parent_info.port = s->parent_result.port;
     update_current_info(&s->current, &s->parent_info, HttpTransact::PARENT_PROXY, (s->current.attempts)++);
     update_dns_info(&s->dns_info, &s->current, 0, &s->arena);
-    HTTP_DEBUG_ASSERT(s->dns_info.looking_up == HttpTransact::PARENT_PROXY);
+    ink_debug_assert(s->dns_info.looking_up == HttpTransact::PARENT_PROXY);
     s->next_hop_scheme = URL_WKSIDX_HTTP;
 
     return HttpTransact::PARENT_PROXY;
@@ -364,7 +363,7 @@ find_server_and_update_current_info(Http
   default:
     update_current_info(&s->current, &s->server_info, HttpTransact::ORIGIN_SERVER, (s->current.attempts)++);
     update_dns_info(&s->dns_info, &s->current, 0, &s->arena);
-    HTTP_DEBUG_ASSERT(s->dns_info.looking_up == HttpTransact::ORIGIN_SERVER);
+    ink_debug_assert(s->dns_info.looking_up == HttpTransact::ORIGIN_SERVER);
     s->next_hop_scheme = s->scheme;
     return HttpTransact::ORIGIN_SERVER;
   }
@@ -387,10 +386,10 @@ do_cookies_prevent_caching(int cookies_c
   int str_len;
 
 #ifdef DEBUG
-  HTTP_DEBUG_ASSERT(request->type_get() == HTTP_TYPE_REQUEST);
-  HTTP_DEBUG_ASSERT(response->type_get() == HTTP_TYPE_RESPONSE);
+  ink_debug_assert(request->type_get() == HTTP_TYPE_REQUEST);
+  ink_debug_assert(response->type_get() == HTTP_TYPE_RESPONSE);
   if (cached_request) {
-    HTTP_DEBUG_ASSERT(cached_request->type_get() == HTTP_TYPE_REQUEST);
+    ink_debug_assert(cached_request->type_get() == HTTP_TYPE_REQUEST);
   }
 #endif
 
@@ -461,7 +460,7 @@ inline static
 HttpTransact::StateMachineAction_t
 how_to_open_connection(HttpTransact::State* s)
 {
-  HTTP_DEBUG_ASSERT(s->pending_work == NULL);
+  ink_debug_assert(s->pending_work == NULL);
 
   // Originally we returned which type of server to open
   // Now, however, we may want to issue a cache
@@ -564,7 +563,7 @@ how_to_open_connection(HttpTransact::Sta
     HttpTransactHeaders::convert_request(s->current.server->http_version, &s->hdr_info.server_request);
   }
 
-  HTTP_DEBUG_ASSERT(s->cdn_saved_next_action == HttpTransact::ORIGIN_SERVER_OPEN ||
+  ink_debug_assert(s->cdn_saved_next_action == HttpTransact::ORIGIN_SERVER_OPEN ||
                     s->cdn_saved_next_action == HttpTransact::ORIGIN_SERVER_RAW_OPEN);
   return s->cdn_saved_next_action;
 }
@@ -1096,7 +1095,7 @@ HttpTransact::HandleRequest(State* s)
 {
   Debug("http_trans", "START HttpTransact::HandleRequest");
 
-  HTTP_DEBUG_ASSERT(!s->hdr_info.server_request.valid());
+  ink_debug_assert(!s->hdr_info.server_request.valid());
 
   HTTP_INCREMENT_TRANS_STAT(http_incoming_requests_stat);
 
@@ -1341,7 +1340,7 @@ HttpTransact::PPDNSLookup(State* s)
 
   Debug("http_trans", "[HttpTransact::PPDNSLookup] This was attempt %d", s->dns_info.attempts);
 
-  HTTP_DEBUG_ASSERT(s->dns_info.looking_up == PARENT_PROXY);
+  ink_debug_assert(s->dns_info.looking_up == PARENT_PROXY);
   if (!s->dns_info.lookup_success) {
     // DNS lookup of parent failed, find next parent or o.s.
     find_server_and_update_current_info(s);
@@ -1351,7 +1350,7 @@ HttpTransact::PPDNSLookup(State* s)
       } else {
         // We could be out of parents here if all the parents
         // failed DNS lookup
-        HTTP_DEBUG_ASSERT(s->current.request_to == HOST_NONE);
+        ink_debug_assert(s->current.request_to == HOST_NONE);
         handle_parent_died(s);
       }
       return;
@@ -1374,7 +1373,7 @@ HttpTransact::PPDNSLookup(State* s)
     // Take care of defered (issue revalidate) work in building
     //   the request
     if (s->pending_work != NULL) {
-      HTTP_DEBUG_ASSERT(s->pending_work == issue_revalidate);
+      ink_debug_assert(s->pending_work == issue_revalidate);
       (*s->pending_work) (s);
       s->pending_work = NULL;
     }
@@ -1402,8 +1401,8 @@ HttpTransact::PPDNSLookup(State* s)
 void
 HttpTransact::ReDNSRoundRobin(State* s)
 {
-  HTTP_DEBUG_ASSERT(s->current.server == &s->server_info);
-  HTTP_DEBUG_ASSERT(s->current.server->connect_failure);
+  ink_debug_assert(s->current.server == &s->server_info);
+  ink_debug_assert(s->current.server->connect_failure);
 
   if (s->dns_info.lookup_success) {
     // We using a new server now so clear the connection
@@ -1501,7 +1500,7 @@ HttpTransact::OSDNSLookup(State* s)
 
   Debug("http_trans", "[HttpTransact::OSDNSLookup] This was attempt %d", s->dns_info.attempts);
 
-  HTTP_DEBUG_ASSERT(s->dns_info.looking_up == ORIGIN_SERVER);
+  ink_debug_assert(s->dns_info.looking_up == ORIGIN_SERVER);
 
   // detect whether we are about to self loop. the client may have
   // specified the proxy as the origin server (badness).
@@ -1580,13 +1579,13 @@ HttpTransact::OSDNSLookup(State* s)
       TRANSACT_RETURN(PROXY_SEND_ERROR_CACHE_NOOP, NULL);
       break;
     default:
-      HTTP_DEBUG_ASSERT(!("try_to_expand_hostname returned an unsupported code"));
+      ink_debug_assert(!("try_to_expand_hostname returned an unsupported code"));
       break;
     }
     return;
   }
   // ok, so the dns lookup succeeded
-  HTTP_DEBUG_ASSERT(s->dns_info.lookup_success);
+  ink_debug_assert(s->dns_info.lookup_success);
   Debug("http_seq", "[HttpTransact::OSDNSLookup] DNS Lookup successful");
 
   // Check to see if can fullfill expect requests based on the cached
@@ -1801,7 +1800,7 @@ HttpTransact::DecideCacheLookup(State* s
       DebugOn("http_trans", "[DecideCacheLookup] Will do cache lookup.");
       DebugOn("http_seq", "[DecideCacheLookup] Will do cache lookup");
     }
-    HTTP_DEBUG_ASSERT(s->current.mode != TUNNELLING_PROXY);
+    ink_debug_assert(s->current.mode != TUNNELLING_PROXY);
 
     if (s->cache_info.lookup_url == NULL) {
       HTTPHdr* incoming_request = &s->hdr_info.client_request;
@@ -1843,7 +1842,7 @@ HttpTransact::DecideCacheLookup(State* s
           s->cache_info.lookup_url->port_set(port);
         }
       }
-      HTTP_DEBUG_ASSERT(s->cache_info.lookup_url->valid() == true);
+      ink_debug_assert(s->cache_info.lookup_url->valid() == true);
     }
 
     TRANSACT_RETURN(CACHE_LOOKUP, NULL);
@@ -2133,7 +2132,7 @@ HttpTransact::issue_revalidate(State* s)
 {
   HTTPHdr *c_resp = find_appropriate_cached_resp(s);
   SET_VIA_STRING(VIA_CACHE_RESULT, VIA_IN_CACHE_STALE);
-  HTTP_DEBUG_ASSERT(GET_VIA_STRING(VIA_DETAIL_CACHE_LOOKUP) != ' ');
+  ink_debug_assert(GET_VIA_STRING(VIA_DETAIL_CACHE_LOOKUP) != ' ');
 
   if (s->www_auth_content == CACHE_AUTH_FRESH) {
     s->hdr_info.server_request.method_set(HTTP_METHOD_HEAD, HTTP_LEN_HEAD);
@@ -2252,7 +2251,7 @@ HttpTransact::HandleCacheOpenReadHitFres
 {
   CacheHTTPInfo *&obj = s->cache_info.object_read;
 
-  HTTP_ASSERT((s->request_sent_time == UNDEFINED_TIME) && (s->response_received_time == UNDEFINED_TIME));
+  ink_release_assert((s->request_sent_time == UNDEFINED_TIME) && (s->response_received_time == UNDEFINED_TIME));
   Debug("http_seq", "[HttpTransact::HandleCacheOpenReadHitFreshness] Hit in cache");
 
   if (delete_all_document_alternates_and_return(s, TRUE)) {
@@ -2273,7 +2272,7 @@ HttpTransact::HandleCacheOpenReadHitFres
   s->request_sent_time = min(s->client_request_time, s->request_sent_time);
   s->response_received_time = min(s->client_request_time, s->response_received_time);
 
-  HTTP_DEBUG_ASSERT(s->request_sent_time <= s->response_received_time);
+  ink_debug_assert(s->request_sent_time <= s->response_received_time);
 
   if (diags->on()) {
     DebugOn("http_trans", "[HandleCacheOpenReadHitFreshness] request_sent_time      : %ld", s->request_sent_time);
@@ -2300,7 +2299,7 @@ HttpTransact::HandleCacheOpenReadHitFres
       s->is_revalidation_necessary = true;      // to identify a revalidation occurrence
       break;
     default:
-      HTTP_DEBUG_ASSERT(!("what_is_document_freshness has returned unsupported code."));
+      ink_debug_assert(!("what_is_document_freshness has returned unsupported code."));
       break;
     }
   }
@@ -2380,7 +2379,7 @@ HttpTransact::need_to_revalidate(State* 
     needs_cache_auth = true;
     break;
   default:
-    HTTP_DEBUG_ASSERT(!("AuthenticationNeeded has returned unsupported code."));
+    ink_debug_assert(!("AuthenticationNeeded has returned unsupported code."));
     return true;
     break;
   }
@@ -2476,7 +2475,7 @@ HttpTransact::HandleCacheOpenReadHit(Sta
     needs_cache_auth = true;
     break;
   default:
-    HTTP_DEBUG_ASSERT(!("AuthenticationNeeded has returned unsupported code."));
+    ink_debug_assert(!("AuthenticationNeeded has returned unsupported code."));
     break;
   }
 
@@ -2599,12 +2598,12 @@ HttpTransact::HandleCacheOpenReadHit(Sta
 
     if (server_up || s->stale_icp_lookup) {
       if (!s->stale_icp_lookup && s->current.server->ip == 0) {
-        HTTP_ASSERT(s->current.request_to == PARENT_PROXY ||
+        ink_release_assert(s->current.request_to == PARENT_PROXY ||
                     s->http_config_param->no_dns_forward_to_parent != 0);
 
         // Set ourselves up to handle pending revalidate issues
         //  after the PP DNS lookup
-        HTTP_DEBUG_ASSERT(s->pending_work == NULL);
+        ink_debug_assert(s->pending_work == NULL);
         s->pending_work = issue_revalidate;
 
         // We must be going a PARENT PROXY since so did
@@ -2631,7 +2630,7 @@ HttpTransact::HandleCacheOpenReadHit(Sta
       s->next_action = how_to_open_connection(s);
       if (s->stale_icp_lookup && s->next_action == ORIGIN_SERVER_OPEN)
         s->next_action = ICP_QUERY;
-      HTTP_ASSERT(s->next_action != ORIGIN_SERVER_RAW_OPEN);
+      ink_release_assert(s->next_action != ORIGIN_SERVER_RAW_OPEN);
 
       return;
     } else {                    // server is down but stale response is returnable
@@ -2656,7 +2655,7 @@ HttpTransact::HandleCacheOpenReadHit(Sta
   // realistically, if we can not make this claim, then there
   // is no reason to cache anything.
   //
-  HTTP_DEBUG_ASSERT((send_revalidate == true && server_up == false) || (send_revalidate == false && server_up == true));
+  ink_debug_assert((send_revalidate == true && server_up == false) || (send_revalidate == false && server_up == true));
 
   if (diags->on()) {
     DebugOn("http_trans", "CacheOpenRead --- HIT-FRESH");
@@ -2672,7 +2671,7 @@ HttpTransact::HandleCacheOpenReadHit(Sta
   if (s->cache_lookup_result == CACHE_LOOKUP_HIT_WARNING) {
     build_response_from_cache(s, HTTP_WARNING_CODE_HERUISTIC_EXPIRATION);
   } else if (s->cache_lookup_result == CACHE_LOOKUP_HIT_STALE) {
-    HTTP_DEBUG_ASSERT(server_up == false);
+    ink_debug_assert(server_up == false);
     build_response_from_cache(s, HTTP_WARNING_CODE_REVALIDATION_FAILED);
   } else {
     build_response_from_cache(s, HTTP_WARNING_CODE_NONE);
@@ -2987,7 +2986,7 @@ HttpTransact::HandleCacheOpenReadMiss(St
   if (!h->is_cache_control_set(HTTP_VALUE_ONLY_IF_CACHED)) {
     find_server_and_update_current_info(s);
     if (s->current.server->ip == 0) {
-      HTTP_ASSERT(s->current.request_to == PARENT_PROXY ||
+      ink_release_assert(s->current.request_to == PARENT_PROXY ||
                   s->http_config_param->no_dns_forward_to_parent != 0);
       if (s->current.request_to == PARENT_PROXY) {
         TRANSACT_RETURN(DNS_LOOKUP, HttpTransact::PPDNSLookup);
@@ -3037,7 +3036,7 @@ HttpTransact::HandleICPLookup(State* s)
 
     // TODO in this case we should go to the miss case
     // just a little shy about using goto's, that's all.
-    HTTP_ASSERT((s->icp_info.port != s->client_info.port) || (s->icp_info.ip != this_machine()->ip));
+    ink_release_assert((s->icp_info.port != s->client_info.port) || (s->icp_info.ip != this_machine()->ip));
 
     // Since the ICPDNSLookup is not called, these two
     //   values are not initialized.
@@ -3066,7 +3065,7 @@ HttpTransact::HandleICPLookup(State* s)
       if (s->current.request_to == PARENT_PROXY) {
         TRANSACT_RETURN(DNS_LOOKUP, PPDNSLookup);
       } else {
-        HTTP_ASSERT(0);
+        ink_release_assert(0);
       }
       return;
     }
@@ -3119,7 +3118,7 @@ HttpTransact::OriginServerRawOpen(State*
   case CONGEST_CONTROL_CONGESTED_ON_M:
     handle_server_died(s);
 
-    HTTP_DEBUG_ASSERT(s->cache_info.action == CACHE_DO_NO_ACTION);
+    ink_debug_assert(s->cache_info.action == CACHE_DO_NO_ACTION);
     s->next_action = PROXY_INTERNAL_CACHE_NOOP;
     break;
   case CONNECTION_ALIVE:
@@ -3129,7 +3128,7 @@ HttpTransact::OriginServerRawOpen(State*
     s->next_action = SSL_TUNNEL;
     break;
   default:
-    HTTP_DEBUG_ASSERT(!("s->current.state is set to something unsupported"));
+    ink_debug_assert(!("s->current.state is set to something unsupported"));
     break;
   }
 
@@ -3168,7 +3167,7 @@ HttpTransact::HandleResponse(State* s)
 
   s->source = SOURCE_HTTP_ORIGIN_SERVER;
   s->response_received_time = ink_cluster_time();
-  HTTP_DEBUG_ASSERT(s->response_received_time >= s->request_sent_time);
+  ink_debug_assert(s->response_received_time >= s->request_sent_time);
   s->current.now = s->response_received_time;
 
   Debug("http_trans", "[HandleResponse] response_received_time: %ld", s->response_received_time);
@@ -3177,13 +3176,13 @@ HttpTransact::HandleResponse(State* s)
 
   HTTP_INCREMENT_TRANS_STAT(http_incoming_responses_stat);
 
-  HTTP_ASSERT(s->current.request_to != UNDEFINED_LOOKUP);
+  ink_release_assert(s->current.request_to != UNDEFINED_LOOKUP);
   if (s->cache_info.action != CACHE_DO_WRITE) {
-    HTTP_ASSERT(s->cache_info.action != CACHE_DO_LOOKUP);
-    HTTP_ASSERT(s->cache_info.action != CACHE_DO_SERVE);
-    HTTP_ASSERT(s->cache_info.action != CACHE_PREPARE_TO_DELETE);
-    HTTP_ASSERT(s->cache_info.action != CACHE_PREPARE_TO_UPDATE);
-    HTTP_ASSERT(s->cache_info.action != CACHE_PREPARE_TO_WRITE);
+    ink_release_assert(s->cache_info.action != CACHE_DO_LOOKUP);
+    ink_release_assert(s->cache_info.action != CACHE_DO_SERVE);
+    ink_release_assert(s->cache_info.action != CACHE_PREPARE_TO_DELETE);
+    ink_release_assert(s->cache_info.action != CACHE_PREPARE_TO_UPDATE);
+    ink_release_assert(s->cache_info.action != CACHE_PREPARE_TO_WRITE);
   }
 
   if (!is_response_valid(s, &s->hdr_info.server_response)) {
@@ -3206,7 +3205,7 @@ HttpTransact::HandleResponse(State* s)
     handle_response_from_server(s);
     break;
   default:
-    HTTP_DEBUG_ASSERT(!("s->current.request_to is not ICP, P.P. or O.S. - hmmm."));
+    ink_debug_assert(!("s->current.request_to is not ICP, P.P. or O.S. - hmmm."));
     break;
   }
 
@@ -3345,11 +3344,11 @@ HttpTransact::handle_response_from_icp_s
       if (s->current.request_to == PARENT_PROXY) {
         TRANSACT_RETURN(DNS_LOOKUP, PPDNSLookup);
       } else {
-        HTTP_ASSERT(0);
+        ink_release_assert(0);
       }
       return;
     }
-    HTTP_DEBUG_ASSERT(&s->hdr_info.server_request);
+    ink_debug_assert(&s->hdr_info.server_request);
     s->next_action = how_to_open_connection(s);
     if (s->current.server == &s->server_info && s->next_hop_scheme == URL_WKSIDX_HTTP) {
       HttpTransactHeaders::remove_host_name_from_url(&s->hdr_info.server_request);
@@ -3401,7 +3400,7 @@ HttpTransact::handle_response_from_paren
       Debug("http_trans", "[hrfp] connection not alive");
       SET_VIA_STRING(VIA_DETAIL_PP_CONNECT, VIA_DETAIL_PP_FAILURE);
 
-      HTTP_DEBUG_ASSERT(s->hdr_info.server_request.valid());
+      ink_debug_assert(s->hdr_info.server_request.valid());
 
       s->current.server->connect_failure = 1;
 
@@ -3451,7 +3450,7 @@ HttpTransact::handle_response_from_paren
       //   origin server
       switch (next_lookup) {
       case PARENT_PROXY:
-        HTTP_DEBUG_ASSERT(s->current.request_to == PARENT_PROXY);
+        ink_debug_assert(s->current.request_to == PARENT_PROXY);
         TRANSACT_RETURN(DNS_LOOKUP, PPDNSLookup);
         break;
       case ORIGIN_SERVER:
@@ -3579,7 +3578,7 @@ HttpTransact::handle_response_from_serve
     handle_server_connection_not_open(s);
     break;
   default:
-    HTTP_DEBUG_ASSERT(!("s->current.state is set to something unsupported"));
+    ink_debug_assert(!("s->current.state is set to something unsupported"));
     break;
   }
 
@@ -3737,9 +3736,9 @@ HttpTransact::delete_server_rr_entry(Sta
             PRINT_IP(s->current.server->ip));
     DebugOn("http_trans", "[delete_server_rr_entry] marking rr entry " "down and finding next one");
   }
-  HTTP_DEBUG_ASSERT(s->current.server->connect_failure);
-  HTTP_DEBUG_ASSERT(s->current.request_to == ORIGIN_SERVER);
-  HTTP_DEBUG_ASSERT(s->current.server == &s->server_info);
+  ink_debug_assert(s->current.server->connect_failure);
+  ink_debug_assert(s->current.request_to == ORIGIN_SERVER);
+  ink_debug_assert(s->current.server == &s->server_info);
   update_dns_info(&s->dns_info, &s->current, 0, &s->arena);
   s->current.attempts++;
   Debug("http_trans", "[delete_server_rr_entry] attempts now: %d, max: %" PRId64 "", s->current.attempts, max_retries);
@@ -3761,10 +3760,10 @@ HttpTransact::delete_server_rr_entry(Sta
 void
 HttpTransact::retry_server_connection_not_open(State* s, ServerState_t conn_state, int max_retries)
 {
-  HTTP_DEBUG_ASSERT(s->current.state != CONNECTION_ALIVE);
-  HTTP_DEBUG_ASSERT(s->current.state != ACTIVE_TIMEOUT);
-  HTTP_DEBUG_ASSERT(s->current.attempts <= max_retries);
-  HTTP_DEBUG_ASSERT(s->current.server->connect_failure != 0);
+  ink_debug_assert(s->current.state != CONNECTION_ALIVE);
+  ink_debug_assert(s->current.state != ACTIVE_TIMEOUT);
+  ink_debug_assert(s->current.attempts <= max_retries);
+  ink_debug_assert(s->current.server->connect_failure != 0);
 
   URL *url = s->hdr_info.client_request.url_get();
   char *url_string = url->valid()? url->string_get(&s->arena) : NULL;
@@ -3813,8 +3812,8 @@ HttpTransact::handle_server_connection_n
     DebugOn("http_trans", "[handle_server_connection_not_open] (hscno)");
     DebugOn("http_seq", "[HttpTransact::handle_server_connection_not_open] ");
   }
-  HTTP_DEBUG_ASSERT(s->current.state != CONNECTION_ALIVE);
-  HTTP_DEBUG_ASSERT(s->current.server->connect_failure != 0);
+  ink_debug_assert(s->current.state != CONNECTION_ALIVE);
+  ink_debug_assert(s->current.server->connect_failure != 0);
 
   SET_VIA_STRING(VIA_SERVER_RESULT, VIA_SERVER_ERROR);
   HTTP_INCREMENT_TRANS_STAT(http_broken_server_connections_stat);
@@ -3832,13 +3831,13 @@ HttpTransact::handle_server_connection_n
   case CACHE_PREPARE_TO_UPDATE:
     /* fall through */
   case CACHE_PREPARE_TO_WRITE:
-    HTTP_ASSERT(!"Why still preparing for cache action - " "we skipped a step somehow.");
+    ink_release_assert(!"Why still preparing for cache action - " "we skipped a step somehow.");
     break;
 
   case CACHE_DO_LOOKUP:
     /* fall through */
   case CACHE_DO_SERVE:
-    HTTP_DEBUG_ASSERT(!("Why server response? Should have been a cache operation"));
+    ink_debug_assert(!("Why server response? Should have been a cache operation"));
     break;
 
   case CACHE_DO_DELETE:
@@ -3859,9 +3858,9 @@ HttpTransact::handle_server_connection_n
   }
 
   if (serve_from_cache) {
-    HTTP_DEBUG_ASSERT(s->cache_info.object_read != NULL);
-    HTTP_DEBUG_ASSERT(s->cache_info.action == CACHE_DO_UPDATE);
-    HTTP_DEBUG_ASSERT(s->internal_msg_buffer == NULL);
+    ink_debug_assert(s->cache_info.object_read != NULL);
+    ink_debug_assert(s->cache_info.action == CACHE_DO_UPDATE);
+    ink_debug_assert(s->internal_msg_buffer == NULL);
 
     Debug("http_trans", "[hscno] serving stale doc to client");
     build_response_from_cache(s, HTTP_WARNING_CODE_REVALIDATION_FAILED);
@@ -3896,7 +3895,7 @@ HttpTransact::handle_forward_server_conn
     DebugOn("http_trans", "[handle_forward_server_connection_open] (hfsco)");
     DebugOn("http_seq", "[HttpTransact::handle_server_connection_open] ");
   }
-  HTTP_ASSERT(s->current.state == CONNECTION_ALIVE);
+  ink_release_assert(s->current.state == CONNECTION_ALIVE);
 
   if (s->hdr_info.server_response.version_get() == HTTPVersion(0, 9)) {
     Debug("http_trans", "[hfsco] server sent 0.9 response, reading...");
@@ -3968,12 +3967,12 @@ HttpTransact::handle_forward_server_conn
   case CACHE_PREPARE_TO_UPDATE:
     /* fall through */
   case CACHE_PREPARE_TO_WRITE:
-    HTTP_ASSERT(!"Why still preparing for cache action - we skipped a step somehow.");
+    ink_release_assert(!"Why still preparing for cache action - we skipped a step somehow.");
     break;
   case CACHE_DO_LOOKUP:
     /* fall through */
   case CACHE_DO_SERVE:
-    HTTP_DEBUG_ASSERT(!("Why server response? Should have been a cache operation"));
+    ink_debug_assert(!("Why server response? Should have been a cache operation"));
     break;
   case CACHE_DO_UNDEFINED:
     /* fall through */
@@ -4292,17 +4291,17 @@ HttpTransact::handle_cache_operation_on_
         client_response_code = HTTP_STATUS_OK;
       }
 
-      HTTP_DEBUG_ASSERT(base_response->valid());
+      ink_debug_assert(base_response->valid());
 
       if (client_response_code == HTTP_STATUS_NOT_MODIFIED) {
-        HTTP_DEBUG_ASSERT(GET_VIA_STRING(VIA_CLIENT_REQUEST) != VIA_CLIENT_SIMPLE);
+        ink_debug_assert(GET_VIA_STRING(VIA_CLIENT_REQUEST) != VIA_CLIENT_SIMPLE);
         SET_VIA_STRING(VIA_CLIENT_REQUEST, VIA_CLIENT_IMS);
         SET_VIA_STRING(VIA_PROXY_RESULT, VIA_PROXY_NOT_MODIFIED);
       } else {
         SET_VIA_STRING(VIA_PROXY_RESULT, VIA_PROXY_SERVED);
       }
 
-      HTTP_DEBUG_ASSERT(client_response_code != HTTP_STATUS_NONE);
+      ink_debug_assert(client_response_code != HTTP_STATUS_NONE);
 
       if (s->next_action == HttpTransact::SERVE_FROM_CACHE && s->state_machine->do_transform_open()) {
         set_header_for_transform(s, base_response);
@@ -4347,7 +4346,7 @@ HttpTransact::handle_cache_operation_on_
       } else if (s->method == HTTP_WKSIDX_HEAD) {
         s->cache_info.action = CACHE_DO_DELETE;
       } else {
-        HTTP_DEBUG_ASSERT(s->cache_info.object_read != 0);
+        ink_debug_assert(s->cache_info.object_read != 0);
         s->cache_info.action = CACHE_DO_REPLACE;
       }
 
@@ -4364,7 +4363,7 @@ HttpTransact::handle_cache_operation_on_
       // do nothing
 
     } else {
-      HTTP_DEBUG_ASSERT(!("cache action inconsistent with current state"));
+      ink_debug_assert(!("cache action inconsistent with current state"));
     }
     // postcondition: s->cache_info.action is one of the following
     // CACHE_DO_REPLACE, CACHE_DO_WRITE, CACHE_DO_DELETE, or
@@ -4447,7 +4446,7 @@ HttpTransact::handle_cache_operation_on_
   }
 
   if ((client_response_code == HTTP_STATUS_NOT_MODIFIED) && (s->cache_info.action != CACHE_DO_NO_ACTION)) {
-    /* HTTP_DEBUG_ASSERT(GET_VIA_STRING(VIA_CLIENT_REQUEST)
+    /* ink_debug_assert(GET_VIA_STRING(VIA_CLIENT_REQUEST)
        != VIA_CLIENT_SIMPLE); */
     Debug("http_trans", "[hcoofsr] Client request was conditional");
     SET_VIA_STRING(VIA_CLIENT_REQUEST, VIA_CLIENT_IMS);
@@ -4456,7 +4455,7 @@ HttpTransact::handle_cache_operation_on_
     SET_VIA_STRING(VIA_PROXY_RESULT, VIA_PROXY_SERVED);
   }
 
-  HTTP_DEBUG_ASSERT(client_response_code != HTTP_STATUS_NONE);
+  ink_debug_assert(client_response_code != HTTP_STATUS_NONE);
 
   // The correct cache action, next action, and response code are set.
   // Do the real work below.
@@ -4474,7 +4473,7 @@ HttpTransact::handle_cache_operation_on_
     // (potentially added by negative revalidating)
     delete_warning_value(base_response, HTTP_WARNING_CODE_REVALIDATION_FAILED);
   }
-  HTTP_DEBUG_ASSERT(base_response->valid());
+  ink_debug_assert(base_response->valid());
 
   if ((s->cache_info.action == CACHE_DO_WRITE) || (s->cache_info.action == CACHE_DO_REPLACE)) {
     set_headers_for_cache_write(s, &s->cache_info.object_store, &s->hdr_info.server_request, &s->hdr_info.server_response);
@@ -4563,7 +4562,7 @@ HttpTransact::handle_no_cache_operation_
     } else {
       Debug("http_trans", "[hncoofsr] next action will be OS_READ_CACHE_NOOP");
 
-      HTTP_DEBUG_ASSERT(s->cache_info.action == CACHE_DO_NO_ACTION);
+      ink_debug_assert(s->cache_info.action == CACHE_DO_NO_ACTION);
       s->next_action = SERVER_READ;
     }
     if (s->state_machine->redirect_url == NULL) {
@@ -4584,7 +4583,7 @@ HttpTransact::handle_no_cache_operation_
       warn_text = "Proxy received unexpected 304 response; content may be stale";
     }
 
-    HTTP_DEBUG_ASSERT(s->cache_info.action == CACHE_DO_NO_ACTION);
+    ink_debug_assert(s->cache_info.action == CACHE_DO_NO_ACTION);
     s->next_action = PROXY_INTERNAL_CACHE_NOOP;
     break;
   case HTTP_STATUS_HTTPVER_NOT_SUPPORTED:
@@ -4604,7 +4603,7 @@ HttpTransact::handle_no_cache_operation_
     Debug("http_trans", "[hncoofsr] server sent back something other than 100,304,200");
     /* Default behavior is to pass-through response to the client */
 
-    HTTP_DEBUG_ASSERT(s->cache_info.action == CACHE_DO_NO_ACTION);
+    ink_debug_assert(s->cache_info.action == CACHE_DO_NO_ACTION);
     s->next_action = SERVER_READ;
     break;
   }
@@ -4789,8 +4788,8 @@ void
 HttpTransact::set_headers_for_cache_write(State* s, HTTPInfo* cache_info, HTTPHdr* request, HTTPHdr* response)
 {
   URL *temp_url;
-  HTTP_DEBUG_ASSERT(request->type_get() == HTTP_TYPE_REQUEST);
-  HTTP_DEBUG_ASSERT(response->type_get() == HTTP_TYPE_RESPONSE);
+  ink_debug_assert(request->type_get() == HTTP_TYPE_REQUEST);
+  ink_debug_assert(response->type_get() == HTTP_TYPE_RESPONSE);
 
   if (!cache_info->valid()) {
     cache_info->create();
@@ -5462,7 +5461,7 @@ HttpTransact::handle_internal_request(St
 
   URL *url;
 
-  HTTP_DEBUG_ASSERT(incoming_hdr->type_get() == HTTP_TYPE_REQUEST);
+  ink_debug_assert(incoming_hdr->type_get() == HTTP_TYPE_REQUEST);
 
   if (incoming_hdr->method_get_wksidx() != HTTP_WKSIDX_GET) {
     return false;
@@ -5486,7 +5485,7 @@ HttpTransact::handle_internal_request(St
 bool
 HttpTransact::handle_trace_and_options_requests(State* s, HTTPHdr* incoming_hdr)
 {
-  HTTP_DEBUG_ASSERT(incoming_hdr->type_get() == HTTP_TYPE_REQUEST);
+  ink_debug_assert(incoming_hdr->type_get() == HTTP_TYPE_REQUEST);
   if (s->method == HTTP_WKSIDX_GET)
     return false;
 
@@ -5676,7 +5675,7 @@ HttpTransact::initialize_state_variables
     s->server_info.name = s->arena.str_store(host_name, host_len);
     s->server_info.port = incoming_request->port_get();
   } else {
-    HTTP_DEBUG_ASSERT(s->server_info.port != 0);
+    ink_debug_assert(s->server_info.port != 0);
   }
 
   s->next_hop_scheme = s->scheme = incoming_request->url_get()->scheme_get_wksidx();
@@ -6522,7 +6521,7 @@ bool
 HttpTransact::is_response_valid(State* s, HTTPHdr* incoming_response)
 {
   if (s->current.state != CONNECTION_ALIVE) {
-    HTTP_DEBUG_ASSERT((s->current.state == CONNECTION_ERROR) ||
+    ink_debug_assert((s->current.state == CONNECTION_ERROR) ||
                       (s->current.state == OPEN_RAW_ERROR) ||
                       (s->current.state == PARSE_ERROR) ||
                       (s->current.state == CONNECTION_CLOSED) ||
@@ -6688,7 +6687,7 @@ HttpTransact::HostNameExpansionError_t H
     ///////////////////////////////////////////////////
     if (s->http_config_param->enable_url_expandomatic) {
       int attempts = s->dns_info.attempts;
-      HTTP_DEBUG_ASSERT(attempts >= 1 && attempts <= max_dns_lookups);
+      ink_debug_assert(attempts >= 1 && attempts <= max_dns_lookups);
 
       if (attempts < max_dns_lookups) {
         // Try a URL expansion
@@ -6721,7 +6720,7 @@ HttpTransact::HostNameExpansionError_t H
     // we looked up dns of parent proxy, but it failed, //
     // try lookup of origin server name.                //
     //////////////////////////////////////////////////////
-    HTTP_DEBUG_ASSERT(s->dns_info.looking_up == PARENT_PROXY);
+    ink_debug_assert(s->dns_info.looking_up == PARENT_PROXY);
 
     s->dns_info.lookup_name = s->server_info.name;
     s->dns_info.looking_up = ORIGIN_SERVER;
@@ -6810,7 +6809,7 @@ HttpTransact::handle_content_length_head
       cl = base->get_content_length();
       if (cl >= 0) {
         // header->set_content_length(cl);
-        HTTP_DEBUG_ASSERT(header->get_content_length() == cl);
+        ink_debug_assert(header->get_content_length() == cl);
 
         switch (s->source) {
         case SOURCE_CACHE:
@@ -6889,8 +6888,8 @@ HttpTransact::handle_content_length_head
 
     } else if (base && base->presence(MIME_PRESENCE_CONTENT_LENGTH)) {
       /* Copy over the content length if its set */
-      HTTP_DEBUG_ASSERT(s->hdr_info.request_content_length == base->get_content_length());
-      HTTP_DEBUG_ASSERT(header->get_content_length() == base->get_content_length());
+      ink_debug_assert(s->hdr_info.request_content_length == base->get_content_length());
+      ink_debug_assert(header->get_content_length() == base->get_content_length());
     } else {
       /*
        * Otherwise we are in a method with a potential cl, so unset
@@ -6929,7 +6928,7 @@ HttpTransact::handle_request_keep_alive_
   bool upstream_ka = ((s->current.server->keep_alive == HTTP_KEEPALIVE) ||
                       (s->current.server->keep_alive == HTTP_PIPELINE));
 
-  HTTP_DEBUG_ASSERT(heads->type_get() == HTTP_TYPE_REQUEST);
+  ink_debug_assert(heads->type_get() == HTTP_TYPE_REQUEST);
 
   // Check preconditions for Keep-Alive
   if (!upstream_ka) {
@@ -6956,7 +6955,7 @@ HttpTransact::handle_request_keep_alive_
     }
   }
 
-  HTTP_DEBUG_ASSERT(ka_action != KA_UNKNOWN);
+  ink_debug_assert(ka_action != KA_UNKNOWN);
 
   // Since connection headers are hop-to-hop, strip the
   //  the ones we received from the user-agent
@@ -6967,7 +6966,7 @@ HttpTransact::handle_request_keep_alive_
   // Insert K-A headers as necessary
   switch (ka_action) {
   case KA_CONNECTION:
-    HTTP_DEBUG_ASSERT(s->current.server->keep_alive != HTTP_NO_KEEPALIVE);
+    ink_debug_assert(s->current.server->keep_alive != HTTP_NO_KEEPALIVE);
     if (ver == HTTPVersion(1, 0)) {
       if (s->current.request_to == PARENT_PROXY ||
           s->current.request_to == ICP_SUGGESTED_HOST) {
@@ -6996,7 +6995,7 @@ HttpTransact::handle_request_keep_alive_
     break;
   case KA_UNKNOWN:
   default:
-    HTTP_DEBUG_ASSERT(0);
+    ink_debug_assert(0);
     break;
   }
 }                               /* End HttpTransact::handle_request_keep_alive_headers */
@@ -7021,7 +7020,7 @@ HttpTransact::handle_response_keep_alive
   { KA_UNKNOWN, KA_DISABLED, KA_CLOSE, KA_CONNECTION };
   KA_Action_t ka_action = KA_UNKNOWN;
 
-  HTTP_DEBUG_ASSERT(heads->type_get() == HTTP_TYPE_RESPONSE);
+  ink_debug_assert(heads->type_get() == HTTP_TYPE_RESPONSE);
 
   // Since connection headers are hop-to-hop, strip the
   //  the ones we received from upstream
@@ -7093,7 +7092,7 @@ HttpTransact::handle_response_keep_alive
   // Insert K-A headers as necessary
   switch (ka_action) {
   case KA_CONNECTION:
-    HTTP_DEBUG_ASSERT(s->client_info.keep_alive != HTTP_NO_KEEPALIVE);
+    ink_debug_assert(s->client_info.keep_alive != HTTP_NO_KEEPALIVE);
     // This is a hack, we send the keep-alive header for both 1.0
     // and 1.1, to be "compatible" with Akamai.
     // if (ver == HTTPVersion (1, 0)) {
@@ -7112,7 +7111,7 @@ HttpTransact::handle_response_keep_alive
     break;
   case KA_UNKNOWN:
   default:
-    HTTP_DEBUG_ASSERT(0);
+    ink_debug_assert(0);
     break;
   }
 }                               /* End HttpTransact::handle_response_keep_alive_headers */
@@ -7260,7 +7259,7 @@ HttpTransact::calculate_document_freshne
       Debug("http_match", "calculate_document_freshness_limit --- Expires header = %d  no date, using sent time %d",
             expires_value, date_value);
     }
-    HTTP_DEBUG_ASSERT(date_value > 0);
+    ink_debug_assert(date_value > 0);
 
     // Getting the cache_sm object
     HttpCacheSM & cache_sm = s->state_machine->get_cache_sm();
@@ -7295,7 +7294,7 @@ HttpTransact::calculate_document_freshne
       *heuristic = true;
       if (date_set && last_modified_set) {
         float f = s->txn_conf->cache_heuristic_lm_factor;
-        HTTP_DEBUG_ASSERT((f >= 0.0) && (f <= 1.0));
+        ink_debug_assert((f >= 0.0) && (f <= 1.0));
         ink_time_t time_since_last_modify = date_value - last_modified_value;
         int h_freshness = (int) (time_since_last_modify * f);
         freshness_limit = max(h_freshness, 0);
@@ -7435,7 +7434,7 @@ HttpTransact::what_is_document_freshness
 
   response_date = cached_obj_response->get_date();
   fresh_limit = calculate_document_freshness_limit(s, cached_obj_response, response_date, &heuristic);
-  HTTP_DEBUG_ASSERT(fresh_limit >= 0);
+  ink_debug_assert(fresh_limit >= 0);
 
   // Fuzz the freshness to prevent too many revalidates to popular
   //  documents at the same time
@@ -7459,7 +7458,7 @@ HttpTransact::what_is_document_freshness
   // did the admin override the expiration calculations? //
   // (used only for http).                               //
   /////////////////////////////////////////////////////////
-  HTTP_DEBUG_ASSERT(client_request == &s->hdr_info.client_request);
+  ink_debug_assert(client_request == &s->hdr_info.client_request);
 
   if (s->txn_conf->cache_when_to_revalidate == 0) {
     ;
@@ -7667,7 +7666,7 @@ HttpTransact::handle_server_died(State* 
 
   switch (s->current.state) {
   case CONNECTION_ALIVE:       /* died while alive for unknown reason */
-    HTTP_ASSERT(s->hdr_info.response_error != NO_RESPONSE_HEADER_ERROR);
+    ink_release_assert(s->hdr_info.response_error != NO_RESPONSE_HEADER_ERROR);
     status = HTTP_STATUS_BAD_GATEWAY;
     reason = "Unknown Error";
     body_type = "response#bad_response";
@@ -7728,7 +7727,7 @@ HttpTransact::handle_server_died(State* 
   case STATE_UNDEFINED:
   case TRANSACTION_COMPLETE:
   default:                     /* unknown death */
-    HTTP_ASSERT(!"[handle_server_died] Unreasonable state - not dead, shouldn't be here");
+    ink_release_assert(!"[handle_server_died] Unreasonable state - not dead, shouldn't be here");
     status = HTTP_STATUS_BAD_GATEWAY;
     reason = NULL;
     body_type = "response#bad_response";
@@ -7839,7 +7838,7 @@ HttpTransact::build_request(State* s, HT
   outgoing_request->version_set(HTTPVersion(1, 1));
 
   // Make sure our request version is defined
-  HTTP_DEBUG_ASSERT(outgoing_version != HTTPVersion(0, 0));
+  ink_debug_assert(outgoing_version != HTTPVersion(0, 0));
 
   // HttpTransactHeaders::convert_request(outgoing_version, outgoing_request); // commented out this idea
 
@@ -7890,7 +7889,7 @@ HttpTransact::build_request(State* s, HT
   s->request_sent_time = ink_cluster_time();
   s->current.now = s->request_sent_time;
   // The assert is backwards in this case because request is being (re)sent.
-  HTTP_DEBUG_ASSERT(s->request_sent_time >= s->response_received_time);
+  ink_debug_assert(s->request_sent_time >= s->response_received_time);
 
 
   Debug("http_trans", "[build_request] request_sent_time: %ld", s->request_sent_time);
@@ -8389,14 +8388,14 @@ ink_cluster_time(void)
 //      lmgmt->record_data->readInteger("proxy.process.http.cluster_delta",
 //                                      &found);
 //     if (! found) {
-//      HTTP_DEBUG_ASSERT(!"Highest delta config value not found!");
+//      ink_debug_assert(!"Highest delta config value not found!");
 //      highest_delta = 0L;
 //     }
 
   Debug("http_trans", "[ink_cluster_time] local: %ld, highest_delta: %d, cluster: %ld", local_time, highest_delta,
         (local_time + (ink_time_t) highest_delta));
 
-  HTTP_DEBUG_ASSERT(highest_delta >= 0);
+  ink_debug_assert(highest_delta >= 0);
 
   local_time += (ink_time_t) highest_delta;
   old = global_time;

Modified: trafficserver/traffic/trunk/proxy/http/HttpTransact.h
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/proxy/http/HttpTransact.h?rev=1068147&r1=1068146&r2=1068147&view=diff
==============================================================================
--- trafficserver/traffic/trunk/proxy/http/HttpTransact.h (original)
+++ trafficserver/traffic/trunk/proxy/http/HttpTransact.h Mon Feb  7 21:38:11 2011
@@ -1402,7 +1402,7 @@ typedef void (*TransactEntryFunc_t) (Htt
 inline void
 HttpTransact::free_internal_msg_buffer(char *buffer, int64_t size)
 {
-  HTTP_DEBUG_ASSERT(buffer);
+  ink_debug_assert(buffer);
   if (size >= 0) {
     ioBufAllocator[size].free_void(buffer);
   } else {

Modified: trafficserver/traffic/trunk/proxy/http/HttpTransactHeaders.cc
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/proxy/http/HttpTransactHeaders.cc?rev=1068147&r1=1068146&r2=1068147&view=diff
==============================================================================
--- trafficserver/traffic/trunk/proxy/http/HttpTransactHeaders.cc (original)
+++ trafficserver/traffic/trunk/proxy/http/HttpTransactHeaders.cc Mon Feb  7 21:38:11 2011
@@ -172,7 +172,7 @@ HttpTransactHeaders::build_base_response
     outgoing_response->create(HTTP_TYPE_RESPONSE);
   }
 
-  HTTP_DEBUG_ASSERT(outgoing_response->type_get() == HTTP_TYPE_RESPONSE);
+  ink_debug_assert(outgoing_response->type_get() == HTTP_TYPE_RESPONSE);
 
   outgoing_response->version_set(HTTPVersion(1, 1));
   outgoing_response->status_set(status);
@@ -279,8 +279,8 @@ void
 HttpTransactHeaders::convert_to_0_9_request_header(HTTPHdr * outgoing_request)
 {
   // These are required
-  HTTP_DEBUG_ASSERT(outgoing_request->method_get_wksidx() == HTTP_WKSIDX_GET);
-  HTTP_DEBUG_ASSERT(outgoing_request->url_get()->valid());
+  ink_debug_assert(outgoing_request->method_get_wksidx() == HTTP_WKSIDX_GET);
+  ink_debug_assert(outgoing_request->url_get()->valid());
 
   outgoing_request->version_set(HTTPVersion(0, 9));
 
@@ -295,7 +295,7 @@ void
 HttpTransactHeaders::convert_to_1_0_request_header(HTTPHdr * outgoing_request)
 {
   // These are required
-  HTTP_DEBUG_ASSERT(outgoing_request->url_get()->valid());
+  ink_debug_assert(outgoing_request->url_get()->valid());
 
   // Set HTTP version to 1.0
   outgoing_request->version_set(HTTPVersion(1, 0));
@@ -320,8 +320,8 @@ HttpTransactHeaders::convert_to_1_1_requ
 {
 
   // These are required
-  HTTP_DEBUG_ASSERT(outgoing_request->url_get()->valid());
-  HTTP_DEBUG_ASSERT(outgoing_request->version_get() == HTTPVersion(1, 1));
+  ink_debug_assert(outgoing_request->url_get()->valid());
+  ink_debug_assert(outgoing_request->version_get() == HTTPVersion(1, 1));
 
   if (outgoing_request->get_cooked_pragma_no_cache() &&
       !(outgoing_request->get_cooked_cc_mask() & MIME_COOKED_MASK_CC_NO_CACHE)) {
@@ -356,8 +356,8 @@ void
 HttpTransactHeaders::convert_to_1_0_response_header(HTTPHdr * outgoing_response)
 {
 //     // These are required
-//     HTTP_DEBUG_ASSERT(outgoing_response->status_get());
-//     HTTP_DEBUG_ASSERT(outgoing_response->reason_get());
+//     ink_debug_assert(outgoing_response->status_get());
+//     ink_debug_assert(outgoing_response->reason_get());
 
   // Set HTTP version to 1.0
   outgoing_response->version_set(HTTPVersion(1, 0));
@@ -374,10 +374,10 @@ void
 HttpTransactHeaders::convert_to_1_1_response_header(HTTPHdr * outgoing_response)
 {
   // These are required
-  HTTP_DEBUG_ASSERT(outgoing_response->status_get());
+  ink_debug_assert(outgoing_response->status_get());
 
   // Set HTTP version to 1.1
-//    HTTP_DEBUG_ASSERT(outgoing_response->version_get() == HTTPVersion (1, 1));
+//    ink_debug_assert(outgoing_response->version_get() == HTTPVersion (1, 1));
   outgoing_response->version_set(HTTPVersion(1, 1));
 }
 
@@ -418,10 +418,10 @@ HttpTransactHeaders::calculate_document_
   // TODO solve this global clock problem
   now_value = max(now, response_time);
 
-  HTTP_DEBUG_ASSERT(response_time >= 0);
-  HTTP_DEBUG_ASSERT(request_time >= 0);
-  HTTP_DEBUG_ASSERT(response_time >= request_time);
-  HTTP_DEBUG_ASSERT(now_value >= response_time);
+  ink_debug_assert(response_time >= 0);
+  ink_debug_assert(request_time >= 0);
+  ink_debug_assert(response_time >= request_time);
+  ink_debug_assert(now_value >= response_time);
 
   if (date_value > 0) {
     apparent_age = max((time_t) 0, (response_time - date_value));
@@ -893,7 +893,7 @@ HttpTransactHeaders::handle_conditional_
 
     // wouldn't be updating cache for range requests (would be writing)
     uint64_t mask = (MIME_PRESENCE_RANGE | MIME_PRESENCE_IF_RANGE);
-    HTTP_ASSERT(header->presence(mask) == mask);
+    ink_release_assert(header->presence(mask) == mask);
 
     /*
      * Conditional Headers

Modified: trafficserver/traffic/trunk/proxy/http/HttpTransactHeaders.h
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/proxy/http/HttpTransactHeaders.h?rev=1068147&r1=1068146&r2=1068147&view=diff
==============================================================================
--- trafficserver/traffic/trunk/proxy/http/HttpTransactHeaders.h (original)
+++ trafficserver/traffic/trunk/proxy/http/HttpTransactHeaders.h Mon Feb  7 21:38:11 2011
@@ -153,7 +153,7 @@ inline bool
 HttpTransactHeaders::is_request_proxy_authorized(HTTPHdr * incoming_hdr)
 {
   NOWARN_UNUSED(incoming_hdr);
-  HTTP_DEBUG_ASSERT(incoming_hdr);
+  ink_debug_assert(incoming_hdr);
   // TODO: What do we need to do here?
   return true;
 }

Modified: trafficserver/traffic/trunk/proxy/http/Makefile.am
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/proxy/http/Makefile.am?rev=1068147&r1=1068146&r2=1068147&view=diff
==============================================================================
--- trafficserver/traffic/trunk/proxy/http/Makefile.am (original)
+++ trafficserver/traffic/trunk/proxy/http/Makefile.am Mon Feb  7 21:38:11 2011
@@ -37,7 +37,6 @@ libhttp_a_SOURCES = \
   Hash_Table.h \
   HttpAccept.cc \
   HttpAccept.h \
-  HttpAssert.h \
   HttpBodyFactory.cc \
   HttpBodyFactory.h \
   HttpCacheSM.cc \



Mime
View raw message