Twelve straw man positions to frame OpenStack “what is core” discussion

THIS POST IS #4 IN A SERIES ABOUT “WHAT IS CORE.”

Train WheelsIt’s time to move to the what from the how and why.  In my experience discussing the framework, it’s important to understand the context at this point because our objective is to define the common ground.  If you mistake the intent then it’s much harder to understand the details, but here they are…

I’m hopeful that the framework we’re defining today will ultimately be taken for granted.  Until then, relax and remember that this straw man is a work in progress.

These positions have been crafted over the course of several weeks and are constantly evolving. Next steps are to expand discussions to the OpenStack Community for input and review at the next Board Meeting on August 6th.   Ultimately, we need to close this issue at the next Summit.

I present them here for reference and encourage the community to bring up dialog on the OpenStack list (positions are sourced here).

Update Aug 13, 2013: These original 12 points have been refined down to 10.

You’re welcome to read the original 12 below, but I recommend skipping over to the refined set.

  1. SINGLE API / MULTIPLE IMPLEMENTATION MODEL (aka PLUG-IN) DESIRED FOR PROJECTS
    1. OpenStack will require an open source reference base plug-in implementation for projects (if not part of OpenStack, license model for reference plug-in must be compatible).
    2. Definition of a plug-in: alternate backend implementations with a common API framework that uses common _code_ to implement the API
    3. This expects that projects (where technically feasible) are expected to implement a plug-in architecture.
    4. This is already in place for several projects and addresses around ecosystem support, enabling innovation
    5. Reference plug-ins are, by definittion, the complete capability set.  It is not acceptable to have “core” features that are not functional in the reference plug-in
  2. API EXTENSION MODEL EXPECTED  FOR PROJECTS
    1. OpenStack will follow architectures patterns that enable API extensions.
    2. This will enable plug-ins to offer innovative or differentiated features without forcing changes to the reference plug-in implementation
    3. This will enable the reference to expand without forcing other plug-ins to match all features and recertify
  3. COMMUNITY MAINTAINED TESTS (TEMPEST?) USED AS BASIS FOR OPENSTACK MARK
    1. Vendor OpenStack implementations must achieve 100% of must-have coverage?
    2. Implemented tests can be flagged as may-have requires list  [Joshua McKenty]
    3. Certifiers will be required to disclose their testing gaps.
    4. This will put a lot of pressure on the Tempest project
    5. Maintenance of the testing suite to become a core Foundation responsibility.  This may require additional resources
  4. VALIDIBLE REMOTE SELF-CERTIFICATION (ON DEMAND TESTING)
    1. Plug-in certification is driven by Tempest self-certification model
    2. Self-certifiers are required to publish their results
    3. Self-certified are required to publish enough information that a 3rd party could build the reference implementation to pass the tests.
    4. Self-certified must include the operating systems that have been certified
    5. It is preferred for self-certified implementation to reference an OpenStack reference architecture “flavor” instead of defining their own reference.  (a way to publish and agree on flavors is needed)
    6. The Foundation needs to define a mechanism of dispute resolution. (A trust but verify model)
  5. SUBSTITUTE PLUG-IN IMPLEMENTATIONS OK
    1. If a vendor plug-in passes all relevant tests then it can be considered a full substitute for the reference plug-in
    2. If a vendor plug-in does NOT pass all relevant test then the vendor is required to include the open source reference in the implementation.
    3. From the may have pick list – must have all must haves. Must haves are ‘core’ See number 12
  6. TESTING CERTIFICATION BY PLUG-IN IF >1 REFERENCE PLUG-IN
    1. Looking forward to having multiple reference plug-ins, Tempest may to distinguish between multiple reference plug-ins.
    2. You can pass certification by passing just one reference test suite + the project tests.
    3. The objective for this position is to allow for future OpenStack functions that requires breaking changes to implementation
  7. OPENSTACK DEFINITIONS APPLY EQUALLY TO ALL DEPLOYMENTS
    1. There should not be multiple definitions of OpenStack depending on the operator (public, private, community, etc)
    2. While expected that each deployment is identical, the differences must be quantifiable.
  8. DISCOVERABLITY OF COMPATIBILITY (VARIATION IS OK)
    1. Implementations and products are allowed to have variation based on publication of compatibility
    2. Consumers must have a way to determine how the system is different from reference (posted, discovered, etc)
    3. Testing must respond in an appropriate way on BOTH pass and fail (the wrong return rejects the entire suite)
    4. We are NOT stating which projects are required in this position
  9. MUST USE OPENSTACK API IMPLEMENTATION CODE
    1. Implementation’s claiming the OpenStack Mark must use the API  framework code
    2. You are not OpenStack, if you pass all the tests but do not use the API framework
    3. This prevents people from using the API without joining the community
    4. This also surfaces bit-rot in “PLUGINS” to the larger community
    5. This behavior improves interoperability because there is more shared code between implementation
  10. API CONSUMERS SELF-CERTIFY AGAINST THE REFERENCE IMPLEMENTATION
    1. As an ecosystem partner, you have a need to make a “works against OpenStack” statement that is supportable
    2. API consumer can claim working against the OpenStack API if it works against any implementation passing all the “must have” tests(YES)
    3. API consumers can state they are working against the OpenStack API with some “may have” items as requirements
    4. API consumers are expected to write tests that validate their required behaviors (submitted as “may have” tests)
    5. The TC will decide which tests are elevated from may-have to must-have
  11. THE “MUST-HAVE” TESTS DEFINE “OPENSTACK CORE”
    1. We are NOT defining which items are on the list in this effort, just making the position that it is how we will define core
    2. May-have tests include items in the integrated release, but which are not core.
    3. We will have a process by which tests are elevated from may to must lists
    4. Potentially: the User Committee will nominate tests that elevated to the board
    5. Must haves – must comply with the Core criteria defined from the IncUp committee results
    6. The OpenStack board owns the responsibility to define ‘core’ – to approve ‘musts’
    7. Projects in Incubation or pre-Incubation are not to be included in the ‘may’ list
  12. SPIDER AND CORE DEFINE A SUBSET OF ALL OPENSTACK TRADEMARKS
    1. There may be other marks that are managed separately by the foundation, and available for the platform ecosystem as per the Boards discretion
    2. “OpenStack API Compatible ” mark not part of this discussion.  Note: position on this is not clear and should be not be assumed.
    3. This topic is difficult to close at this time and requires a breath of testing that does not yet exist
    4. This is a temporary working position that may be revisited

READ POST IS #5: COMMUNITY FEEDBACK

9 thoughts on “Twelve straw man positions to frame OpenStack “what is core” discussion

  1. Pingback: Kicking off discussion about OpenStack Core | Rob Hirschfeld

  2. Pingback: One more exchange on the AWS API question. | Speaking of Clouds - Distributed applications and virtual infrastructures

  3. Rob hi, what is your view on extensions validation? How do we make sure that what extended has required level of maturity?

    • Great question! This is how I see it trending…

      My expectation is that an extension that someone wants to make broadly available will include “may-pass” tests that can be used to validate the extension is working and installed. Since they are may-pass, it’s ok if they fail. That is enough for broad adoption.

      If those extensions become widely adopted, the Foundation could upgrade the tests to must-pass. At that point, the extension would be considered core OpenStack.

      Does that help?

  4. Pingback: Visualizing the OpenStack Core discussion points | Rob Hirschfeld

  5. Pingback: My insights from OpenStack “what is core” Spider > we need pluggable architectures | Rob Hirschfeld

  6. Pingback: refined: 10 OpenStack Core Positions | Rob Hirschfeld

  7. Pingback: OpenStack における議論のループ : それを示す1枚のチャート | Agile Cat --- in the cloud

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s