Draft: draft-ietf-taps-interface

Commentary: Took a stab at normative language for the rules to process Selection Properties , as discussed in . As far as I remember , we always said that outcomes have to be deterministic / consistent , so I made everything that matters a MUST . I guess our example illustrates that even given the same Selection Properties , the outcome might change depending on the situation , e.g. , your path might still be  but it might or might not support your preferred protocol . So , does this really have to be all MUST , or is there a SHOULD in there ? Discuss . :) Also , if anyone can name a good reason why the outcome has to be deterministic , please suggest text - maybe something like " avoid surprises for the application " , but this did n't really sound right , so I left it out for now . 
 In section 5.2 . in the API doc : " Internally , the transport system will first exclude all protocols and paths that match a Prohibit , then exclude all protocols and paths that do not match a Require , then sort candidates according to Preferred properties , and then use Avoided properties as a tiebreaker . Selection Properties that select paths take preference over those that select protocols . For example , if an application indicates a preference for a specific path by specifying an interface , but also a preference for a protocol not available on this path , the transport system will try the path first , ignoring the preference . " This sounds rather like an example algorithm that should maybe go into the implementation doc instead ? Or is there any part of this that we need to specify normatively in order to ensure that all systems implement the same ? 
 This goes back to issue on " conflicting policies " . At the time , we decided that there must be a deterministic outcome , therefore , text was to both the API and the Implementation document , see . If we keep it that way , perhaps the text here should point out that the goal is to resolve conflicting policies , so we achieve a deterministic outcome . 
 Ah okay , thanks for the background info ; missed that . I think we need to use normative language here then . Maybe also a separate subsection makes this more prominent . 
 This reads to me like the rules for processing polices rather than an example algorithm . I think it is part of the API ... Normative language would be good and a stronger opening that explains why the rules exist . 
 I do n't think a separate subsection would make this a better read - this fits fine as it stands , as an intro to the transport property specification IMO . Regarding normative language , that 's a separate discussion . So , can we close this issue ? 
 Agree that we do n't need a separate subsection . I can try to tweak the beginning of this part a bit to explain why the rules exist as suggested . Regarding normative language - we definitely have it in the API draft , right ? So why not have the discussion on it here as well ? if we 're serious about deterministic outcomes , I guess the whole thing needs to be a MUST , right ? 
 Sorry , true , that normative language debate was about the arch draft , and we definitely have it in the API draft . So yes , let 's discuss it here . I also think a MUST would make sense . 
 So the order of filtering out require / prohibit is not important ( outcome is the same ) - making the order a MUST does not make sense . Also , first sorting by preference and then filtering has the same outcome as doing it the other way around . the only thing we need to say is that filtering MUST happen and sorting SHOULD happen . 
 ok - I have to admit I did n't think this through , I just agree that we want a deterministic outcome from this . 
 Why did we require a deterministic behavior in first place ? Does this prevent TAPS implementations from running experiments like Apple did with TCP SACK and ECN ? Does this prevent probabilistic path probing ? 
 This was discussed in the TAPS BoF ? ... I thought it was about developers being assured that X will happen if they choose Y and not finding the ground shifting as they use the interface . 
 Interim : Prefers and avoids allow the implementation to decide the ordering and weighting ; require and prohibit are the only hard requirements . Applications should be able to cope with any possibility that is n't prohibited . Likely should add implementation text to say how preferences weight racing . 
 During the interim discussion , we found that was too strict and limiting , so we opted for another approach that moves the selection algorithm to the Implementation draft . I 'm preparing another PR implementing these changes . 
 The text that ended up in the implementation draft is not fully consistent with the racing text , opening a new issue for this and closing this issue . 
 LGTM , merging this . thanks , Theresa!This reads good to me . Regarding the request for text , I do n't have any ideas ... but I think this could be fine as it stands ? Needs more eyes though .
Paragraph (version A):
Internally, the transport system will first exclude all protocols and
paths that match a Prohibit, then exclude all protocols and paths
that do not match a Require, then sort candidates according to
Preferred properties, and then use Avoided properties as a
tiebreaker.  Selection Properties that select paths take preference
over those that select protocols.  For example, if an application
indicates a preference for a specific path by specifying an
interface, but also a preference for a protocol not available on this
path, the transport system will try the path first, ignoring the
protocol preference.
Paragraph (version B):
The implementation MUST ensure a consistent outcome given the same
Selection Properties.  Internally, it MUST exclude all protocols and
paths that match a Prohibit and exclude all protocols and paths that
do not match a Require.  It MUST then sort candidates according to
Preferred properties, and then use Avoided properties as a
tiebreaker.
Paragraph (version B):
Note that the protocols and paths which are available on a specific
system may vary, such that application preferences may conflict with
each other.  For example, if an application indicates a preference
for a specific path by specifying an interface, but also a preference
for a protocol, a situation might occur in which the preferred
protocol is not available on the preferred path.  In such cases,
implementations MUST ensure a deterministic outcome by prioritizing
Selection Properties that select paths over those that select
protocols.  Therefore, the transport system MUST try the path first,
ignoring the protocol preference if the protocol does not work on the
path.