Re: [sip-overload] draft-ietf-soc-overload-control-07 section 6.3 algorithm

[Adam Roach <[e-mail]>]

On 3/8/12 2:27 PM, Vijay K. Gurbani wrote:
> I'd respectfully urge you one more time to see if you can make sense
> with the context that get_sip_msg() picks up the next SIP message from
> its processing queue to focus on the overload control part.  But if
> that is still not clear, then I am open to suggestions on how to
> proceed.  I can work with you to break this up into two processing
> loops and see if they make things more understandable.

If you're really concerned about the concurrency implications of showing 
this as two different loops, I'm okay collapsing it into a single loop 
servicing a work queue. But we really need to be clear about where the 
messages are coming from.

I think you really do want to show something that works for both user 
agents and for proxies. I don't think most implementors will be able to 
adapt what you have right now into something applicable to user agents. 
On the other hand, if you split things up to handle message receipt 
separately from message sending, then use in a user agent context 
becomes much clearer.

What's nice about doing it that way is that it allows you to completely 
ignore the complexities of proxy message handling (e.g. forking) by 
hiding them behind the "process_msg" function.

So, here's what I propose. It's based heavily on your most recent code, 
but it handles inbound and outbound messages separately and explains 
where the SIP messages are coming from:

cat1 := 80.0         // Category 1 --- subject to reduction
cat2 := 100.0 - cat1 // Category 2 --- Not subject to reduction
                      // 80/20 mix.


while (true)
{
   // We're modeling message processing as a single work queue
   // that contains both incoming and outgoing messages.
   sip_msg := get_next_message_from_work_queue()

   switch (sip_msg.type) {

     case outbound request:
       destination := get_next_hop(sip_msg)
       oc_context := get_oc_context(destination)

       if (oc_context == null)  {
           send_to_network(sip_msg) // Process it normally by sending the
           // request to the next hop since this particular destination
           // is not subject to overload
       }
       else  {
          // Determine if server wants to enter in overload or is in
          // overload
          in_oc := extract_in_oc(oc_context)

          oc_value := extract_oc(oc_context)
          oc_validity := extract_oc_validity(oc_context)

          if (in_oc == false or oc_validity is not in effect)  {
             send_to_network(sip_msg) // Process it normally by sending the
              // request to the next hop since this particular destination
              // is not subject to overload.  Optionally, clear
              // the oc context for this server (not shown).
          }
          else  {
             category := assign_msg_to_category(sip_msg)
             drop_msg := false
             pct_to_reduce := min(100, oc_value / cat1 * 100)

             r := random()
             if (r <= pct_to_reduce)  {
                drop_msg := true
             }

             if (category == cat2 && drop_msg == true)  {
                if (local_policy(sip_msg, oc_value) says process message) {
                    drop_msg := 0  // See Note 1 below
                }
             }

             if (drop_msg == false) {
                 send_to_network(sip_msg) // Process it normally by sending
                // the request to the next hop
             }
             else  {
                // Do not send request downstream, handle locally by
                // generating response (if a proxy) or treating as
                // an error (if a user agent).
             }
          }
       }

     end case // outbound request

     case outbound response:
       if (we are in overload) {
         add_overload_parameters(sip_msg)
       }
       send_to_network(sip_msg)

     end case // outbound response

     case inbound response:

        if (sip_msg has oc parameter values)  {
            create_or_update_oc_context()  // For the specific server
            // that sent the response, create or update the oc context;
            // i.e., extract the values of the oc-related parameters
            // and store them for later use.
        }
        process_msg(sip_msg)

     end case // inbound response

     case inbound request:

        if (sip_msg does not have oc parameter values &&
            we are in overload)  {
          r := random()
          if (r <= our overload metric that we're advertising) {
            send_response(sip_msg, 503)
          }
          else {
            process_msg(sip_msg)
          }

        }

     end case // inbound request


   }
}

I have at least one other major issue I think needs to be fixed, but I 
don't want to throw it into the mix until we have preliminary agreement 
on how we break up the processing.

/a