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(-)