incubator-deltacloud-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From lut...@redhat.com
Subject Sketch of CIMI model layer
Date Wed, 02 Nov 2011 23:08:13 GMT

This patch is a first attempt at a CIMI model layer. Such a layer is needed
to deal with deserialization (and possibly serialization) of CIMI model
objects from (to) XML/JSON, and to give us a place to stash business logic
connected to model classes.

This patch is solely for discussion, it most definitely will not work; at a
minimum there are various 'require' that are missing.

There's two things that make such a model layer interesting:

  * The need to deal with differences between the JSON and XML
    representation; I believe they are all mechanical, though the CIMI
    draft does not set out any explicit rules. The main rule is that an
    array of things in JSON is represented as { 'things': [ .. array .. ] }
    whereas the XML uses a sequence of <thing/> elements
  * The desire to keep the metadata that has to be written for each model
    class minimal

Since we need to capture some of the metadata in the model classes anyway
(at a bare minimum we need to know which attributes are arrays, so that we
can handle JSON and XML differently), I think it will also be possible to
do serializiation of model classes programmatically, rather than through
templates.

The intended use of the model classes is something like (of course, in
reality, this code will be scattered through various places like server.rb
and the drivers)

  templ = nil
  if input_is_xml(input)
    templ = MachineTemplate.from_xml(input)
  else
    templ = MachineTemplate.from_json(input)
  end
  machine = Machine.new

  machine.name = templ.name
  machine.volumes = templ.volumes.dup
  templ.volume_templates.each do |vt|
    machine.volumes << setup_volume_from_template(vt)
  end

  # Do more stuff with templ, adding to machine
  respond_to do |fmt|
    fmt.xml { machine.to_xml }
    fmt.json { machine.to_json }
  end

Besides getting the code to actually be syntactically correct, there are a
few more additions that seem useful:

  * make sure we strip out unneeded arrays from XmlSimple (i.e., some
    scalars are returned as '[ v ]', but we should only use 'v'
  * add a way to the DSL to indicate whether an attribute is mandatory or
    optional, i.e. something like

      ref :uri, :mandatory => true

    With that, we could do some rudimentary validation on model objects

  * see if we can really have a Base.to_xml; the two big issues to settle
    are
      (1) indicate which attributes go into XML attributes and which ones
          go into elements, e.g.
            ref :foo, :xml_attr => true

      (2) for attributes that are not scalars, do (1) recursively; in
          particular, allow associating a class with the members of an
          array

            array :things, :class => Thing

          where Thing itself is a subclass of Base

  * some type specific validation (a 'ref' should look like a URI, we could
    add types to 'scalar' and make sure integers look like integers etc.)

  * a unit test or two

Another sidenote: since the CIMI API isn't terribly HTML friendly (e.g.,
POST's all have XML or JSON bodies), I wonder if the HTML frontend
shouldn't be a JS app that communicates with the server via JSON only.

David

Mime
View raw message