[netmod] js review of draft-ietf-netmod-schema-mount-09

[Juergen Schoenwaelder <[e-mail]>]

Here is my review of draft-ietf-netmod-schema-mount-09.

* Abstract

   This document defines a mechanism to combine YANG modules into the
   schema defined in other YANG modules.

  I do not know what this says - I think this text is confusing. What
  does it mean to 'combine' YANG modules? What is the notion of
  'schema' used here? Does the text help someone to decide whether
  this mechanisms is something worth to study in order to solve a
  given modeling problem?  (A good abstract would IMHO do that.)

  Note that the mount mechanisms has serious limitations as well that
  perhaps need to spelled out right up-front, i.e., it only works with
  pre-defined mount-points (augments are much more flexible in this
  regard, the schema mount defined here is by its very design not
  very flexible.

* Introduction

  s/Furthermore,//

  'In some cases' ... 'often' - hm is this something that is required
  occasionally or often? There are more uses of fill words like
  'often' that do not really seem to be needed.

  s/new generic mechanism/new mechanism/

  While I think I understand the difference made between
  implementation-time and run-time, the description is somewhat
  confusing since the run-time mount will also be exposed via YANG
  library and hence defining implementation-time by 'defined by a
  server implementor and is as stable as YANG library information of
  the server' is somewhat fuzzy. I assume what you mean is that in the
  case 2. the mounted schema is fixed at implementation time while in
  the case 3. the mounted schema may vary and be discovered at
  run-time. However, you do not define things this way but rather talk
  about properties that do however not define things.

* Glossary of New Terms

     o  top-level schema: a schema according to [RFC7950] in which schema
      trees of each module (except augments) start at the root node.

  You do not import 'schema' from RFC 7950 since, well, it is not
  defined in RFC 7950. I think you often mean a schema tree (as
  defined in RFC 7950) when you use 'schema'. Well, even this is not
  true since a 'schema tree' according to RFC 7950 is scoped to a
  module. RFC 8342 defines a 'datastore schema' but then I am not sure
  this corresponds to 'schema' as used in this draft. In fact, the
  mounted schema may be considered part of the 'datastore schema'.  I
  think we are handwaving with our terminology here but then perhaps I
  am the only one who cares...

  What we actually have are schema tree (of a module per RFC 7950) and
  a collection of schema trees sharing a common root (this is likely
  what is meant with "schema" in this document). And then schema mount
  simply provides a mechanism to have additional (statically defined)
  roots in a schema.

* Specification of the Mounted Schema

  I still struggle with the term 'inline' (and to a lesser extend with
  'shared'). I am likely in the minority.

* Multiple Levels of Schema Mount

  What is a 'subschema'? What is a 'schema level'? Is a subschema the
  same as a schema, i.e. a collection of schema trees with a common
  root? If we need terms such as 'subschema' or 'schema level', then
  we should define them. But perhaps just some tweaking the text to
  avoid new terms can solve the issue.

* Referring to Data Nodes in the Parent Schema

  I stumbled across this here but in general is 'data model' the same
  as 'schema'? Note that the text in section 4 talks about 'mounted
  data model' and 'top-level data model' and 'mounted data model' but
  elsewhere you talk about * schemas. Perhaps using just one term is
  better and more consistent?

  Why are parent-references only useful for the 'shared-schema' case?
  An 'inline' mount can't refer to stuff outside the mount jail?

  Looking at the YANG definition of 'parent-reference', I am left
  somewhat clueless in which situations these xpath expressions are
  evaluations and when the nodesets are merged with other xpath
  expression evaluation results. It seems that these parent references
  are the only actual difference between 'inline' and 'shared-schema'
  mounts.

* Data Model

  I have not really understood what the difference between 'inline'
  and 'shared-schema' is. I understand that the later can have
  'parent-references' but it is unclear why the other can't and if
  there is not strong architectural reason why there have to be two
  choices. It also seems that the 'namespace' list is only meaningful
  if there are parent references, no? So why is this then global, i.e.
  also provided for 'inline' mounts? I guess I do not really
  understand the distinction. If there are no parent-references, what
  is the difference between 'shared-schema' and 'inline'?

* Security Considerations

  I agree with others that something needs to be said how NACM applies
  to mounted schemas.

/js

PS: I have not checked the examples in the appendix.

-- 
Juergen Schoenwaelder           Jacobs University Bremen gGmbH
Phone: [phone]         Campus Ring 1 | 28759 Bremen | Germany
Fax:   [phone]         <https://www.jacobs-university.de/>