Open Stack

We are overjoyed to announce the release of:

murano 2.0.0: Murano API

This release is part of the mitaka release series.

For more details, please see below.

2.0.0
^^^^^


New Features
************

* Now all native MuranoPL methods (those that are written in Python)
  have "?muranoMethod" metadata key referring to MuranoMethod instance
  for the method.

* Classes to work with Cinder volumes were added to core library.
  Now it is possible to create new volume from various sources or use
  existing volume. Also it is possible to attach volumes to instances.
  This doesn't include ability to boot instances from volumes.

* Class configs are now also versioned. For class foo.bar version
  1.2.3 the following file names will be examined: foo.bar-1.2.3.json
  foo.bar-1.2.3.yaml foo.bar-1.2.json foo.bar-1.2.yaml foo.bar-1.json
  foo.bar-1.yaml In addition for classes of version 0.x.y file name
  without version suffix are also examined as a last attempt so the
  backward compatibility is retained

* New plugin 'murano_heat-translator_plugin' was added. Now it is
  possible to deploy applications from CSAR templates.

* Enable mocks in MuranoPL tests cases.

* Added >>:command:`murano-test-tunner`<< command to run murano
  package tests.

  <SYSTEM MESSAGE: <string>:17: (ERROR/3) Unknown interpreted text
  role "command".>

* Introduced two YAQL *inject* functions to enable mocks "def
  inject(target, target_method, mock_object, mock_name)" and "def
  inject(target, target_method, yaql_expr)".

* New method type: extension methods. Extension methods enable you
  to "add" methods to existing types without modifying the original
  type. Extension methods are a special kind of static method, but
  they are called as if they were instance methods on the extended
  type. Extension methods are identified by "Usage: Extension" and the
  type they extend is determined by their first argument contract.
  Thus such methods must have at lease one parameter.

* New type-level keyword "Import" which can be either list or scalar
  that specifies type names which extensions methods should be
  imported into class context and thus become available to type
  members.

* Added filter by 'Name' which only matches package name.

* All HOT template outputs are put into a single dictionary property
  'templateOutputs' rather than in a generated property per each
  output. As a result there are no more constraints on output names.

* Added magnum plugin to murano, that allows creating/deleting of
  magnum baymodels and bays from MuranoPL

* Added ability to extend MuranoPL entities with custom metadata.

* For MuranoPL classes new key "Usage" was added. By default it is
  "Class". But it can also be "Meta" to define meta-class. Meta-class
  has all the capabilities of regular classes and in addition has 3
  new attributes: Cardinality, Applies and Inherited.

* It is possible to attach meta-class instances to packages, classes
  (including other meta-classes), properties, methods and method
  arguments. Each of them got new "Meta" key containing list (or
  single scalar) of meta-class instances.

* Now it is possible to have several classes in one YAML file.
  Classes are separated using YAML document separator (3 dashes).
  Empty documents are skipped. If the class doesn't have Namespace
  section corresponding section from the previous class in the same
  file is used. Thus it is possible to declare namespace prefixes once
  at the file header. Even if there are several classes in one file
  all of them are still required to be declared in manifest file.

* Add multiple engine workers

* New operator *is* was added to MuranoPL. Now it is possible to
  test if MuranoPL object is of particular type.

* Murano engine is now capable of caching packages on disk for
  reuse. This is controlled by *packages_cache* directory path and
  *enable_packages_cache* boolean parameter (true by default). The
  packages are cached in a eventlet/inter-process safe manner and are
  cleaned up as soon as newer version of the package becomes available
  (unless it's used by ongoing deployment)

* Added public field to environment templates. GET method for api
  now displays public templates from other projects(tenants).

* Added public filter to environment templates api.

* Added clone action to environment templates.

* Basic reflection capabilities were added to MuranoPL. Now it is
  possible to get type info with typeinfo() function and using it as a
  starting point obtain information about the class, its methods and
  properties as well as the package of the class. Reflected properties
  can be used to obtain or set its value in a given object or invoke
  its method.

* Static methods and properties were introduced. Both properties and
  methods can be marked as Usage: Static Statics can be accessed using
  ns:Class.property / ns:Class.method(), :Class.property /
  :Class.method() to access class from current namespace or
  type('full.name').property / type('full.name').method() to use full
  type name.

* io.murano.configuration.Linux methods are now static

* Heat stacks created by murano during environment deployment now
  have 'murano' tag by default. This is controlled by "stack_tags"
  config parameter.

* Murano was migrated to yaql 1.1

* New format MuranoPL/1.3 can be specified in manifest files.
  MuranoPL/1.3 is identical to MuranoPL/1.2 but except for the fact
  that MuranoPL/1.3 packages cannot be imported to earlier Murano
  versions. Thus applications that use new features of yaql 1.1 should
  use this format version.


Known Issues
************

* Enabling multiple workers might break workflows under BSD and
  Windows systems


Upgrade Notes
*************

* When updating to Mitaka, the operator should update service name
  and type for endpoint in keystone from "application_catalog" to
  "application-catalog" if SQL is used for catalog back-end driver.


Bug Fixes
*********

* Murano is now able to work with keystone configured to use a
  templated catalog.

* It was impossible to explicitly provide attribute owner class to
  getAttr/setAttr methods without using namespace prefix or if the
  type was not from the core library.

* Murano is now able to assign correct floating IPs when using
  multiple external networks. It attempts to choose one that shares a
  router with internal network.

* Avoid race condition during parallel upload of packages, when
  packages have same tags.

* Fixed incorrect murano behaviour if deployed on devstack with
  keystone v3 by default.

* RequestContext now serialises it's roles. This should allow murano
  to work correctly (and allow rules like "role:xxx" in policy.json)
  when using oslo.context prior to 2.2.0 and oslo.policy

Changes in murano 2.0.0.0rc2..2.0.0
-----------------------------------

579731a Destroy orphan objects
f2b8c28 Don't use bash eval for Linux.runCommand

Diffstat (except docs and test files)
-------------------------------------

meta/io.murano/Resources/RunCommand.template   | 15 ++++++-----
meta/io.murano/Resources/scripts/runCommand.sh | 14 ----------
murano/common/engine.py                        |  7 ++++-
murano/dsl/executor.py                         | 37 ++++++++++++++++++++------
murano/dsl/object_store.py                     |  6 +++++
murano/dsl/serializer.py                       |  5 ++--
murano/engine/system/agent.py                  | 12 +++++----
8 files changed, 60 insertions(+), 38 deletions(-)