Subject: Re: [Rserpool] Data transmission

From: Qiaobing Xie <[email-masked]>
Date: Wed, 01 Aug 2001 14:19:31 -0500

Miguel Angel Nieto Jimenez wrote:
...snip...

>   ------------------------------------------------------------------------
> Hi,
>    This is the way how I understand the ASAP protocol. In the primitives I only have
>  indicate the most importants parameters. As the primitives were incompleted in the
> draft, I have added some of them that I consider are necessaries. For example,
> asap.bind to inform ASAP about their users. Maybe there are some points that could
> be application specific, but they help me to understand the overall problem.
> 
>  These are some of the abbreviations I have used:
> 
> The addresses of the different elements are:
> PU: IP=IP1, port=P1
> PE: IP=IP2, port=P2
> ASAP1: IP=IP1, port=P3 (well-known port)
> ASAP2: IP=IP2, port=P3
> 
> I1, I2, I3 are the SCTP instance identifiers. These parameters are locals to the node
> A1, A2, A3, ... are the association identifiers.
> 
> AUI: Asap user identifier. It is used to by ASAP to identify its users. There is a table that maps
> "Asap user identifiers" to "Instance identifiers". ASAP doesn't return the Instance identifier to the
> user to avoid this uses SCTP directly.
> 
> CI: Communication identifier. It is passed to the ASAP user to identify associations. There is a table
>  that maps "Communication identifiers" to "Associations identifiers". ASAP doesn't return the Instance
> identifier to the user to avoid this uses SCTP directly.
> 
> ph is the pool handle
> 
> I have supposed that ASAP@PU starts generating I,A,CI and AUI identifiers from 0 while ASAP@PE starts
> from 50.
> 
> This is the sequence:
> 
> PU           ASAP@PU         SCTP                      SCTP           ASAP@PE         PE
> 
> 1. ASAP notifies SCTP that it is an user (when the stack is initialized)
>                 sctp.initialize.req(IP1,P1)                sctp.initialize.req(IP2,P3)
>                ---------------->                         <--------------
>                 sctp.initialize.conf(I1)                    sctp.initialize.conf(I50)
>                <----------------                         -------------->
> 
> 2.- PE and PU bind to its underlying ASAP layer.
>                                                                           asap.bind.req(IP2,P2)
>                                                                         <--------------
>                                                            sctp.initialize.req(IP2,P2)
>                                                          <--------------
>                                                            sctp.initialize.conf(I2)
>                                                          -------------->
>                                                                      (Map I2 to AUI50)
>                                                                      asap.bind.conf(AUI50)
>                                                                         -------------->
> 
>   asap.bind.req(IP1, P1)
> -------------->
>                 sctp.initialize.req(IP1,P1)
>                --------------->
>                 sctp.initialize.conf(I1)
>                <---------------
>                (Map I1 to AUI1)
>   asap.bind.conf(AUI1)
> <--------------
> 

The above is more or less about how the layers inside the node find and
set-up with each other. These are IMO implementation details and will
probably not be covered by the protocols.

> 3.- PE register itself in the ENRP server
>                                                                          asap.register.req(AUI50,ph)
>                                                                         <--------------
>                                                                         (ASAP@PE opens an association
>                                                                          to the ENRP node using P3 port
>                                                                          and get a register itself)
> 
>                                                                          asap.register.conf()
>                                                                         -------------->

Yes, if the ASAP@PE already knows the whereabouts of an ENRP server.
Otherwise, it may need to use multicast (to well-known channel/port) or
DNS to find an ENRP server first.

(3.5 At the start up time, the PU may do the registration as well. The
by-product of doing a reg is to find itself a home ENRP server and
set-up an association w/ it)

> 4.- Data transmission.
> 
>   asap.send.req(AUI1,ph,data)
> -------------->
>   (ASAP@PU verifies that AU1 is its user. Maps
>    AUI1 to I1)
> 
>   (ASAP@PU opens an association to the ENRP node
>    using P3 port

Yes, if the ASAP@PU already knows its ENRP server. Otherwise, it will
need to discover one first.

>    and get a list of PE for the
>    pool requested. One of them is selected (IP2,P2)
>    according to the policy)
> 

If ph is already in the local cache of ASAP@PU, then all the above can
be skipped.

>                 sctp.associate.req(I1,IP2,P2)
>                --------------->
>                 sctp.associate.conf(A1)
>                <---------------
> 
>                 sctp.comm_up.ind(I1,A1,IP2)               sctp.comm_up.ind(I50,A50,IP1)
>                <---------------                          -------------->

Yes, if this is the first time talking to the PE. Otherwise, you skip
the above.

>                 sctp.send.req(A1, data)
>                --------------->
>                (Map A1 to CI1)
>   asap.send.conf(CI1)
> <--------------
> 
>                                                           sctp.data_arrive.ind(A50,data)
>                                                          -------------->
>                                                                         (Map A50 to CI50)
> 
>                                                                         asap.data_received(CI50, data)
>                                                                         -------------->
>                                                                         asap.send(AUI50, CI50,data)
> 
>                                                                         <--------------
>                                                                         (Verify that the user and
>                                                                          communication exits)
>                                                           sctp.send(A50,data)
>                                                           <------------
> 
> 
>                 sctp.data_arrive.ind(A1,data)
>                <---------------
>                (Map A1 to CI1)
>   asap.data_received(CI1,data)
> <--------------
> 
> (PU can send again to the same pool element)
>   asap.send.req(AUI1,CI1,data)
> -------------->
> ...
> ...
> ...
> ...
> 
> Is this sequence OK?
> 
> Regards
>     Miguel Angel
>

_______________________________________________
rserpool mailing list
[email-masked]
http://www.ietf.org/mailman/listinfo/rserpool